SystemsDIFFICULTY: AdvancedSTATUS: Prototype

OptiCore Core Router Simulator

High-Performance Router Simulation & Factorial Experimentation

GitHub Repository

Client / ScopeAcademic / Telecom Simulation Initiative

My RoleLead Systems Developer

Duration4 Months

Completion Date2025-11-20

1. SYSTEM OVERVIEW

Executive Summary

A routing engine simulator analyzing OSPF vs EIGRP performance under varying traffic levels and Access Control List (ACL) constraints, complete with interactive configuration widgets and raw data export.

Business Problem

Network engineers lacked predictable data to model how core routing CPU and packet loss respond when scaling ACL databases from 10 to 1,000 rules under massive workloads.

Business Impact Value

Enabled telemetry-driven router selection for telecom topologies, reducing routing bottlenecks and optimizing budget allocations for edge deployments.

Key Engineering Goals

Simulate high-throughput network configurations deterministically
Generate CPU and packet loss telemetry conforming to physical router bottlenecks
Expose file-explorer API matching standard Linux networking configurations

My System Responsibilities

Developed simulation engine math templates executing factorial models
Designed interactive frontend explorer displaying GitHub-hosted source scripts
Engineered multi-variant interpolation scripts modeling memory/delay dynamics

2. SYSTEM FEATURES

Router Performance SimulatorComplexity: High

Interactive controller letting engineers specify OSPF/EIGRP configs, ACL ranges, and custom packet workloads.

Impl:Multi-variant mathematical interpolation based on real physical testbeds.

GitHub Source ExplorerComplexity: Medium

Live interactive file browser retrieving current codebase contents directly from Git.

Impl:Fetches raw github content dynamically with custom loader states and syntax framing.

CSV Experiment ExporterComplexity: Low

Enables downloading full multi-variant baseline dataset for offline mathematical analysis.

Impl:Dynamic table rendering and structured CSV parsing.

3. SYSTEM ARCHITECTURE

Physical-to-mathematical mapping system. Performs numerical linear interpolation across a 3x3 multi-variant grid of routing configurations obtained from actual laboratory router tests.

Topology Vector Diagram

Telemetry Parameters (Protocol, ACL, PPS) ──> React UI Simulator State
                                                     │
                                                     ▼
Interpolation Engine <──[Factorial CSV Matrix Data]──┘
   │
   ├──> CPU Consumption (%)
   ├──> Memory Allocated (MB)
   ├──> Router Delay (µs)
   └──> Packet Loss Rate (%)

Pipeline flow sequences

User selects configuration (e.g. EIGRP, 100 ACL, 50,000 PPS)

React state captures input parameters

Interpolation function locates adjacent coordinate rows in data matrix

Calculates weighted average of CPU, memory, delay, and loss values

Outputs metrics into real-time telemetry panels

Repo directory structure

opticore/
├── opticore_sim.py            # Python simulation script
├── requirements.txt           # Environment specifications
├── router_performance_results.csv # Factorial raw baseline data
├── index.html                 # Classic frontend mockup
├── index.css
└── index.js

4. INTERACTIVE SIMULATOR WIDGET

Run active operations audits utilizing the custom sandbox telemetry receiver widget below.

Routing Protocol

ACL Entries count

Traffic Workload

Custom PPS (1k - 300k)

CPU Consumption

--%

RAM Allocated

-- MB

Routing Latency

-- µs

Packet Loss Rate

--%

5. ENGINEERING ARCHITECTURE DECISIONS (ADRs)

Decision ProfileDetermine simulator execution model (Server-side execution vs Client-side interpolation)

Context

We wanted immediate slider updates on user interactions without server running costs or API call overhead.

Alternatives Checked

Dockerized Python endpoint
WASM-compiled routing models
Client-side linear interpolation across factorial matrix

Selected Decision

Client-side linear interpolation across factorial matrix

Advantages

Zero server latency, updating UI in under 1ms
Perfect offline execution capability
Eliminates maintenance costs for cloud execution environments

Disadvantages

Restricted to pre-profiled configuration parameters
Cannot simulate novel dynamic routing events beyond the baseline matrix

Trade-off details

Sacrificed dynamic network routing simulations in favor of perfect UI performance and zero backend host dependency.

Future Scaling direction

Compile the full python networking engine to WebAssembly (WASM) to support dynamic client-side route parsing.

6. DETAILED TECHNOLOGY STACK

frontend

• React• TypeScript• TailwindCSS

backend

• Python (Simulation Engine)

testing

• PyTest• Mocks

monitoring

• CSV telemetries• Plotting scripts

7. SECURITY REVIEW & POSTURE

Secure GitHub Content Ingestion

Explorer fetches code files dynamically, running risk of Cross-Site Scripting (XSS) if files contain malicious scripts.

Mitigation StrategyIngests raw text directly, rendering text inside locked read-only elements with zero DOM parsing or raw HTML injection.

8. PERFORMANCE METRICS TELEMETRY

Telemetry Calculation Time<0.5ms

Optim:O(1) matrix lookup and lightweight client-side linear interpolation math.

Code Fetch Latency180ms

Optim:Direct integration with GitHub raw CDN endpoints with background state caching.

9. ENGINEERING CHALLENGES & RESOLUTIONS

Vulnerability Bottleneck

Simulating exponential delays and high-scale packet drops under heavy overload using linear math was wildly inaccurate.

Root Cause:Under high PPS and ACL ranges, physical router buffers overflow, causing sudden spikes in delay and loss rather than a gradual rise.

System Investigation

Plotted raw testbed results and identified a clear threshold where queues hit capacity and performance degraded exponentially.

Engineering Solution

Replaced simple linear interpolation with multi-stage piecewise formulas that incorporate a step-penalty when traffic exceeds queue capacity.

Trade-offs accepted

Increased code logic complexity slightly, adding condition-checks for capacity levels.

Lessons Derived

Physical bottlenecks have thresholds; math models must incorporate physical constraints like queue capacities to remain authentic.

10. SYSTEM LESSONS LEARNED

Engineering Lessons

Factorial datasets must be structured cleanly in JSON or CSV to keep parser code minimal and maintainable.

Architecture Lessons

Decoupling the data layer from the math rendering logic allowed us to modify the routing matrix without changing UI components.

Business Lessons

Providing direct codebase transparency (source explorer) significantly increases trust in academic and technical systems.

System Redesign Plans

I would implement interactive SVG topologies visualizing packets flowing through nodes in real time.

11. ROADMAP & TECHNICAL DEBT

Support custom CSV uploads for user-defined hardware profiles
Integrate BGP routing simulator configurations
Export results as complete PDF design briefs

12. GITHUB SOURCE EXPLORER

Audit raw repository script configurations directly inside the active terminal workspace.

HarizuAru/OptiCoremain

Open on GitHub

Workspace Files

Encoding: UTF-8Lines: 1

Let's discuss your project

Interested in building a secure auto-scaling platform similar to this?

Schedule Consultation All Projects

Keep exploring

Related Projects

All projects →

Networking · WebPrototype

OptiNet

A prototype mapping network telemetry streams to visualize delay, jitter, and packet drop trends.

ArchitectureTrigger → Telemetry Calculator → Dashboard

networking
telemetry
react
React
TypeScript

Case Study GitHub

AI · WebDemo

ResumeAI Optimization Platform

An AI-powered resume optimizer analyzing professional summaries against target job descriptions, providing real-time ATS scores and impact-driven writing tips.

ArchitectureResume Text → Client Parser → ATS Score · API → LLM → Rewrite

llm
typescript
react
security
product-ux

Case Study GitHub

WebPrototype

Telemetrix

A dashboard rendering dynamic logs and bar charts to monitor live software application metrics.

ArchitectureStream Trigger → Loop Generator → Bar-Chart Dashboard

telemetry
charts
react
React
TypeScript

Case Study GitHub