Octoculus

• 

  octoculus examining a tor(dark web) packet in a simulation

Inspiration

While building a test suite for ipqdp, I needed something I couldn’t find: a network environment realistic enough to exercise real IP behavior, but controllable enough to debug like a test harness. Traditional mocks were too shallow, and full virtualized environments were too heavy and slow for fast iteration. Octoculus(Octo- eight, Oculus - eye) literally means eight eye, which is a characteristic of spiders, which are known for weaving massive webs and sense to catch bugs and hold them in place. I wanted it to be something that would be as versatile as a spider on its web.

What it does

Octoculus is a realtime IP simulation platform where each node runs JavaScript on Deno and a Rust host orchestrates the entire network asynchronously. It includes a web interface that visualizes node connectivity and live traffic, and gives full runtime control: freeze the simulation, inspect nodes/packets/edges, drop selected packets, destroy nodes, add nodes, and insert firewall-like interceptors between nodes.
It delivers realistic distributed behavior with direct, ergonomic, intuitive, and interactive observability.

How we built it

We built the simulation core in Rust using Tokio, channels, and a microsecond-based simulation clock to manage packet transit, scheduling, and jitter. Node programs run inside embedded Deno runtimes via deno_core ops, exposed through a lightweight JS API for send/receive/time/config interactions.
On top of that, we added a control plane and web UI: the backend streams topology and packet events, and the frontend provides live graph visualization plus mutation controls for packets, nodes, and links in-flight.

Challenges we ran into

The hardest part was synchronizing Rust’s simulation loop with JavaScript async execution while preserving correctness and determinism. I also had to solve hot node injection without stale runtime/module state, and design safe mutation semantics so UI actions (pause, drop, kill, intercept) could happen live without corrupting simulation state. I had to mask the JavaScript layer perfectly to code as if it was a normal application without sacrificing performance.

Accomplishments that we're proud of

I built a lightweight but powerful simulator that behaves like a real IP environment and is still easy to inspect and control. The web UI turned Octoculus from a backend simulator into an interactive network lab, making debugging and fault injection dramatically faster.

What we learned

I learned that architectural conciseness and control must be first-class design goals in simulation systems, not afterthoughts. We also learned how far a Rust + Deno hybrid architecture can go when responsibilities are cleanly split: Rust for high-performance orchestration, JavaScript for asynchronous, ergonomic, flexible node behavior.

What's next for Octoculus

Next, we’re expanding scenario tooling: reproducible replay, broadcast, and other protocols. We also plan to scale larger swarms and add stronger analysis overlays so Octoculus can serve as a general-purpose platform for network protocol development and experimentation.

Built With

• deno
• javascript
• rust