Interactive visual explainers for engineers
Hard ideas,
shown not told.
CODExSIMS offers interactive software engineering explainers and visual systems tutorials for databases, distributed systems, AI, JVM and browser internals.
- 56 interactive explainers
- Source-backed
- Watch, read and change inputs
Explore the catalog
56 explainers
Storage engines, query execution, streaming systems and the protocols that keep data correct.
25 explainersHow does Postgres read old rows without locking everything up?
How Postgres actually decides which row version you see, why vacuum exists and what freezing has to do with transaction wraparound.
How does an LLM-maintained wiki compound knowledge over time?
What happens when an LLM maintains its own wiki instead of re-deriving the same answers on every query.
How does DuckDB turn SQL into vectorized pipelines so quickly?
Why DuckDB is so fast: how SQL becomes a physical plan that gets sliced into vectorized pipelines operating on column chunks.
Why do Kafka consumers stop for a rebalance and reshuffle?
Why consumers stop, what the coordinator actually does during a rebalance and how cooperative revocation makes it less painful.
How do Cassandra nodes discover peers and detect failures without a leader?
How seeds bootstrap discovery, generation and version tuples reject stale knowledge, peer exchanges spread state, and local failure detectors judge reachability.
How can distributed systems order events when clocks disagree?
How happens before becomes logical time, how vectors expose concurrency, and how uncertainty aware clocks support safe real time ordering.
How does Jepsen find distributed system bugs under real faults?
How Jepsen prepares a real cluster, schedules concurrent operations, injects network and process faults, records honest histories, and checks linearizability.
When does a retried operation really happen only once?
How delivery guarantees differ from effect guarantees, how idempotency patterns absorb retries, and where Kafka exactly-once semantics stop.
How does Git turn files into immutable history under the hood?
An engineering-level tour of canonical object bytes, loose-object fanout, index-to-tree assembly, commit and ref resolution, reachability, structural sharing, packfiles and delta storage.
What really happens inside a MySQL index lookup?
How InnoDB stores rows in clustered leaves, descends separators, splits full pages, follows secondary keys, and trades read speed for write and cache cost.
What do databases mean when they promise consistency?
Why these four words are not interchangeable, which anomaly each model forbids and where Spanner, Cockroach, Postgres and DynamoDB actually sit on the lattice.
Why do RocksDB LSM trees stay write-fast even when compaction gets messy?
The shared LSM skeleton behind both engines: how writes stay fast through the WAL and memtables while compaction quietly reshapes levels.
How does Flink keep duplicate writes out of the picture?
How Flink cuts a barrier through a live stream, snapshots state at every operator and replays cleanly after a crash.
How can you check a distributed protocol across every ugly interleaving?
A high-school-friendly path from state machines and invariants through PlusCal, TLA+ model checking, stale-leader counterexamples, epoch fencing and refinement.
How do realtime workers keep ClickHouse ingestion fast and safe?
How worker pools read ordered stream lanes, batch and shape rows, insert blocks into ClickHouse, and use part pressure plus retries to keep offsets safe.
How does Pinot keep stream rows queryable while it builds immutable segments?
A code-backed tour from Kafka fetch and mutable indexing through winner election, split commit, seven pauseless stages, and failure-specific repair.
How does Pinot keep one logical row while old versions remain inside segments?
A code-backed tour of full upsert record selection, valid and queryable bitmaps, deletes, out-of-order policy, compaction, recovery, TTL, and consistent query views.
How do databases merge a record that carries only a few changed fields?
A cross-database guide to overwrite, increment and append semantics through MongoDB, DynamoDB, PostgreSQL, Cassandra, Redis Active-Active and retry guards.
How does Pinot turn one SQL query into coordinated distributed stages?
A source-backed journey from broker planning and leaf scans through mailbox exchange, local hash joins, partial aggregation, root output, and stage-level diagnosis.
How does Spark choose between broadcast speed and shuffle pain?
How Spark picks between broadcast and shuffle, why sort merge joins dominate at scale and what AQE does when data skew shows up.
How does Iceberg time travel without copying the whole table?
How Iceberg gets time travel and branching without ever rewriting a data file, just by being clever with metadata pointers.
How does Arrow make columnar data zero-copy across every language?
The full Arrow IPC file format from columnar memory layout through validity bitmaps, buffer alignment, record batch serialization, footer random access and the zero-copy mmap read path.
How does the Parquet file format organize columns and skip data?
The full Parquet file format from columnar vs row storage through row groups, page internals, dictionary/RLE/delta encodings, Dremel repetition and definition levels and predicate pushdown.
How does RAG dig up the right context?
How RAG digs up the right context: chunking, embeddings, approximate nearest neighbor search, reranking and grounded answer generation.
How do you search 100 GB of text without scanning it?
Build full-text search from raw bytes: analyze terms, invert postings, test phrase positions, size and bulk-load shards, merge BM25 results, and maintain immutable segments.
From transformer internals to agent loops, retrieval, prompting and real-time inference.
19 explainersHow does a large language model turn text into a response?
The full transformer architecture from tokenization through embeddings, self-attention, multi-head attention, transformer blocks and autoregressive generation.
How do tokens stream from an LLM to your screen in real time?
What actually happens between stream:true and the first token on screen, including the SSE framing and backpressure nobody talks about.
How does LangChain grow one model call into a real LLM app?
How one model call grows into prompts, memory, chains, evals and agents across the full LangChain course arc.
How do OpenAI prompts become reliable production artifacts?
Why prompt order matters, how examples shape behavior, what structured outputs actually guarantee and the eval loop that hardens it all.
What turns one model call into a reliable LLM application?
A software engineering tour of context budgets, instruction authority, sampling, reasoning, streaming, schemas, tools, routing, retries and token cost.
How do you test an AI system that can answer differently on every run?
A practical evaluation system for probabilistic software, from golden datasets and regression tests through retrieval, grounding, tools, judges, humans, production signals and repeated model or prompt comparisons.
How does DeepSeek-V4 fit a million-token context on the same hardware?
The architecture rewrites behind DeepSeek-V4: CSA plus HCA hybrid attention, doubly-stochastic hyper-connections, the Muon optimizer, MegaMoE wave-pipelined EP, and the stability tricks that kept a 1.6T-parameter MoE alive during training.
How do DeepSeek-V4 architecture and training work together?
A source-backed tour of DeepSeek-V4 residual mixing, compressed attention, sparse expert training, stability systems and specialist distillation.
How do Kimi K3 architecture, data, and training fit together?
A source-backed deep dive into Kimi K3 sparse routing, long-context attention, depth retrieval, data-disclosure boundaries, low-precision training and serving.
How did an AI security evaluation escape its sandbox and reach production?
A source-backed reconstruction of how an OpenAI cyber evaluation escaped its test environment, reached Hugging Face production and changed containment practice.
How does pretraining change what reinforcement learning can achieve?
A paper-backed tour of how pretraining loss and token exposure predict RL returns, how compute allocation shifts, and what RL changes inside easy and hard reasoning policies.
How does a self-learning agent turn conversations into lasting capability?
How a fresh agent turns conversations into memory, skills and searchable episodes so the next session is smarter than the last.
How does Claude Code route prompts, tools, hooks, and plugins?
How prompts, tools, hooks and plugins actually flow through Claude Code from the CLI entry point to the edges where MCP takes over.
How does Clanker Cloud turn one prompt into grounded cloud evidence?
How one prompt gets cleaned up, routed to the right backend, hydrated with credentials and fanned out into parallel evidence gathering.
What is OpenClaw actually doing in local control mode?
What one local gateway actually does: normalizing channels, mapping sessions, running the agent loop and coordinating paired devices.
Why does an AI agent loop feel more structured than it looks?
Why an agent loop feels more structured than it looks: planning, tool calls, memory and guardrails working as one deliberate cycle.
How do you wire Java, Claude and OpenSearch into a working agent?
A practical code walkthrough: Maven dependencies, system prompt, tool schemas, the agent for-loop, switch-case handler and a live end-to-end trace.
Why do LLM tokens come out one tiny step at a time?
Why tokens come out one at a time: the full path from prompt assembly through prefill, KV cache reuse and the autoregressive decode loop.
How would you design the GPU platform behind a ChatGPT-scale service?
A public-mechanism design exercise spanning streaming contracts, workload tails, GPU memory, parallelism, KV admission, continuous batching, failure handling, autoscaling and useful-token cost.
How does JFR record profiles with under 1% overhead?
The full JFR recording pipeline: annotated event types, lock-free thread-local buffers, async stack sampling via SIGPROF, constant pool deduplication, and self-describing chunk rotation.
How does Java allocate and free memory outside the garbage-collected heap?
The full off-heap path: how allocateDirect() reserves native memory through Bits and malloc, how PhantomReference + Cleaner free it, the raw Unsafe escape hatch, memory-mapped file mechanics and NMT zone tracking.
How does ZGC achieve sub-millisecond GC pauses on terabyte heaps?
The full ZGC cycle: colored pointers carry GC state in every reference, multi-mapped memory makes them hardware-friendly, and the load barrier self-heals stale pointers so marking and relocation run concurrently.
Browsers, developer platforms, consensus, deployment and network behavior.
6 explainersWhere does browser INP get stuck in the rendering pipeline?
How bytes become pixels through the rendering pipeline and where exactly INP pressure shows up when the main thread gets stuck.
How do you go from zero to a useful Clanker workflow?
The actual path from zero to useful with Clanker: install, config, first grounded question and then maker plans that talk to real backends.
How does Netlify turn one deploy into a globally served site?
How one git push becomes a globally served site through immutable deploys, edge POPs and instant rollback that just works.
How does Cursor Origin keep Git fast, durable, and consistent?
A source-backed tour of Continuity, the Git storage system beneath Cursor Origin, from packfile locality and WAL publication through CAS races, verified reads, shared compaction and elastic replicas.
How does Raft keep quorum alive when the leader goes down?
How silence becomes an election, why majority replication is the commit rule and what happens to a stale leader after failover.
How do you solve centre-of-mass and collision problems without losing the signs?
A Class 11 mechanics path from mass-weighted position and centre-of-mass motion through signed momentum, restitution, elastic and inelastic collisions, and a checked two-dimensional solving workflow.
Focused visual notes from experiments, media formats and production systems.
3 explainersWhy did X For You put this post on my screen?
Why that post showed up on your For You: how Home Mixer retrieves candidates, filters them and lets the Phoenix ranker pick the winners.
Why did Slowrun tweaks stack in such weird ways?
Why the same hyperparameter wins or fails depending on what else is in the stack, and how the author figured that out the hard way.
How do MIDI files turn tiny note events into actual sound?
How a MIDI file encodes timing, tempo and channel messages in a format small enough to fit on a floppy disk but expressive enough to drive a full sequencer.