Highlights

Built a deterministic protocol engine: same architecture, seed and carried state always produce a byte-identical event stream, which makes stepping backwards, scrubbing and run comparison exact.

Implemented MD4, SHA-256, AES, DES and RSA from scratch with full internal tracing, verified against FIPS-197 and other official vectors.

Shipped 34 preset architectures, 48 component kinds, 27 sandboxed Break-It failure modes and a 143-entry concept knowledge base.

323 tests passing, typecheck and production build green, and the Rust probe clean under clippy with warnings denied.

Technical Implementation

Engine and UI separation: All protocol logic lives in an engine layer that never imports React. The UI has no hand-authored animation sequences; it animates whatever the engine emits. Randomness goes through a seeded PRNG, and state that only matters between requests (edge cache, connection pool, TLS tickets, ARP table, BGP state) is carried in an explicit run context, so a cache MISS followed by a HIT is observable without breaking determinism.

Protocol depth: HTTP/1.1, HTTP/2 and HTTP/3 produce genuinely different stacks. HTTP/2 encodes real HPACK bytes with dynamic-table eviction; HTTP/3 runs over QUIC with QPACK and emits no TCP events at all. BGP announcements propagate through real RIBs with policy and RPKI, a Kubernetes Service picks an endpoint from a real EndpointSlice, and a request cannot leave the host until ARP has resolved the gateway.

Real cryptography: The complete TLS 1.3 key schedule (RFC 8446 §7.1), QUIC Initial protection keys checked against RFC 9001's own vectors, X25519MLKEM768 hybrid key exchange, ML-KEM, ML-DSA and SLH-DSA, and measured PBKDF2, scrypt and Argon2id in a worker. Ethernet, IPv4, TCP, UDP, ICMP and TLS record headers are built byte by byte with real checksums.

Live analysis: A server route measures real hosts (DNS records, TLS version, cipher, ALPN, certificate chain, response headers) and labels every value as observed, inferred, simulated or unknown. Live observations are converted into ordinary engine events so the same timeline and inspector render them, and the clock only advances by what was actually measured.

Rust raw-socket probe: A zero-dependency Rust service that builds DNS queries and TLS ClientHellos by hand, writes them to the socket and parses the replies field by field, so the group a server actually selected is observed rather than inferred from a library's conclusions.

Design Decisions & Challenges

The main rule was never to fabricate. Where something is not executed, such as XTS mode, the app says so instead of producing fake ciphertext. Live runs report byte counts as unknown when that vantage point cannot see them, and a server's own reason phrase is shown rather than a made-up "OK".

Real requests are guarded on where they can go: private, loopback, link-local and cloud metadata addresses are refused, redirects are not followed automatically, request and response sizes are capped, and CR/LF in headers is rejected as injection. The UI names the target host and method before anything is sent.

Writing tests surfaced real bugs: a bare hostname silently falling back to a default domain, a hostname validator in the probe that accepted a lone hyphen, and a node selection loop that cleared the canvas. Performance budgets were also flaky under parallel test workers, so the benchmarks moved to their own serial pass and use the best of several runs.

The limits are documented rather than hidden: packet payloads are described rather than sealed byte for byte, BGP omits MRAI timers, and Kubernetes is modelled behaviourally rather than as an iptables or eBPF datapath.