Interactive simulators

Interactive simulators for circuits, signals, mechanics and more.

• SPI Bit-Shift Simulator — Run a real byte transfer, clock by clock. Master and slave shift registers exchange a byte one SCLK edge at a time: set the byte each side sends, choose the SPI clock mode, then step or run the transfer and watch MOSI and MISO move bit by bit.
• I²C Transaction Simulator — Run a real transaction, bit by bit. Build a complete I²C register write or read — START, 7-bit address with R/W bit, register, data, ACK/NACK, repeated START and STOP — and step through it on the SDA/SCL lines.
• UART Frame Simulator — Watch a real frame go out, bit by bit. Send one byte over a UART line and watch the frame form: idle, start bit, 8 data bits LSB-first, optional parity and stop bits, with the bit timing computed for the selected baud rate.
• CAN Bus Network Simulator — A live five-ECU bus with faults, plus six protocol labs. Five ECUs share one CAN bus: watch arbitration, ACK, error frames, TEC/REC and bus-off in real time, inject faults (lone node, faulty transceiver, babbling idiot, noise, overload) and compare observed latencies with worst-case response-time analysis. Extra labs encode bit-exact classical and CAN FD frames with error injection, compute bit timing, decode DBC signals, segment ISO-TP messages and decode J1939/CANopen IDs.
• RTOS Scheduler Simulator — Watch preemption and priority inversion, tick by tick. Three tasks of high, medium and low priority share a mutex. Step through the timeline to see preemption, then the classic priority-inversion problem — and how priority inheritance fixes it.
• Microcontroller Register Simulator — Watch a line of C become a hardware pin change. Follow a register access from C source to silicon: a GPIO write that turns on an LED, or an ADC read of a sensor — through the compiled instruction, the bus, the peripheral register and the pin.
• Memory & Execution Lab — Ten interactive models of memory and program execution. Explore a process memory map, step through stack frames and recursion, drive a heap allocator (first/best/next fit, fragmentation, leaks), inspect byte layouts and IEEE 754 floats, walk the build pipeline, single-step a tiny CPU, translate virtual addresses through a TLB and page table, simulate cache hits and misses, track object lifetimes, and budget an MCU's flash and RAM.
• Concurrency Lab — Fourteen interactive models of threads, locks and async code. Step through thread timelines, provoke race conditions and fix them with a mutex or an atomic, wait on condition variables, find deadlock cycles in wait-for graphs, check happens-before claims, trace promises and the event loop, push a producer-consumer pipeline into overload, starve a thread pool, cancel a task tree, and schedule an RTOS task set with priority inheritance.
• Runtime Lab — Lexers, parsers, bytecode and virtual machines you can step through. Type a program in MiniLang and watch it become tokens, an AST and bytecode; step the tree-walk interpreter and the stack VM instruction by instruction; disassemble and verify raw bytes; compare stack and register code; explore closures, garbage collection and a JIT tier simulation; read real JVM, .NET, CPython, V8 and WebAssembly bytecode; and see a verifier reject malformed code.
• Security Lab — Defensive tools: threat models, safe queries, encoding, crypto and more. Build a STRIDE threat model and risk register; compare parameterized and concatenated SQL (the safe one runs on SQLite in your browser); encode one value for five output contexts; check file paths and outbound URLs; hash passwords with real PBKDF2; test an authorization matrix by injecting bugs; tamper with real AES-GCM ciphertext; audit security headers and cookies; simulate rate limiters; verify signed webhooks; drive a secure order state machine; and redact logs.
• Build & Git Lab — Dependency graphs, version ranges, cache keys, commit graphs and CI pipelines. Mark a file changed and watch which targets rebuild (and which go stale when a dependency is undeclared); compare Debug and Release builds with numbers from real compiles; resolve npm-style version ranges; compute real SHA-256 cache keys; stage, commit, restore and reset files; merge, rebase and cherry-pick on a commit graph; compute real Git blob IDs; bisect a regression; and run a CI pipeline with failures, flaky tests and caches.
• Algorithms Lab — Step through sorting, trees, graphs, DP, hashing and more. Watch six sorting algorithms compare and swap; run binary search and its bound variants; rewire a linked list; push and pop stacks, queues and a circular buffer; insert into hash tables with chaining or probing; grow a BST and balance it as an AVL tree; sift a heap; union and find with path compression; step BFS, DFS, Dijkstra, Prim, Kruskal and topological sort; fill LCS, edit-distance and knapsack tables; query segment and Fenwick trees; trace KMP; and backtrack through N-Queens.