Explore a browser engine
Twenty-four lessons, Rust/WASM executions and six interactive models connect URLs and HTTP to HTML, CSS, JavaScript, events, scheduled work and repainting.
Study the concepts, combine the execution models, then build the Rust project. Actual WASM executions and measured QEMU records are labelled separately.
Build, diagnose and repair
Rust / WASM
Connect HTML, CSS, clicks, timers, microtasks and paint. Repair six bugs and inspect actual Rust execution.
Repair checks: 0 / 6
Loading…
Local implementation (self-reported): Not recorded
Start the implementation →Your reading and questions
Loading learning records…
Demo predictions and repair results appear separately below and are saved on this device.
Read and experiment in order
Foundations
Follow relative-URL resolution and separate the connection destination, request target, and in-document fragment.
Try the interactive model · Practise · Write a noteFoundations
Separate start lines, headers, and body bytes, then handle incomplete input without confusing transport chunks with message boundaries.
Try the interactive model · Practise · Write a noteFoundations
Follow text, tag, and quoted-attribute states, preserving the information a tree builder needs.
Try the interactive model · Practise · Write a noteFoundations
Turn start tags, end tags, attributes, and text into a small document tree while distinguishing the model from full HTML recovery.
Try the interactive model · Practise · Write a noteFoundations
Separate selector matching, specificity, source order, and inheritance while deriving a computed style from competing declarations.
Try the interactive model · Practise · Write a noteFoundations
Build layout boxes and drawing commands from document and style data, then trace the effects of hiding an element or changing width.
Try the interactive model · Practise · Write a noteExecution models
Connect source locations, operator precedence, and tree structure so that evaluation follows a defined expression rather than the visual order of characters.
Try the interactive model · Practise · Write a noteExecution models
Trace bindings, calls, returns, and closures separately, and explain why a function looks up names through its defining environment.
Try the interactive model · Practise · Write a noteExecution models
Preserve node identity while following creation, insertion, movement, removal, and text changes into the state needed for later rendering.
Try the interactive model · Practise · Write a noteExecution models
Follow capture, target, and bubble along a tree, distinguishing target, currentTarget, listener order, and handlers that a stop flag prevents from being reached.
Try the interactive model · Practise · Write a noteExecution models
Separate running work, two queues, microtask checkpoints, and rendering opportunities to explain the order of state changes and visible updates.
Try the interactive model · Practise · Write a noteExecution models
Keep document state, computed geometry, and the last painted image separate while comparing measurement-driven updates and batched writes in a declared model.
Try the interactive model · Practise · Write a noteRust implementation
Use ownership, enums, and UTF-8 byte ranges to return HTML tokens and positioned diagnostics from editable input.
Run Rust / WASM · Practise · Write a noteRust implementation
Build a consistent DOM from tokens using arena indices and an open-element stack, then test recovery policies and structural boundaries.
Run Rust / WASM · Practise · Write a noteRust implementation
Apply a limited CSS cascade and inheritance to the same DOM, then compute coordinates and drawing commands from content widths, spacing, and text lines.
Run Rust / WASM · Practise · Write a noteRust implementation
Connect a shared Rust pipeline, the WASM ownership contract, deterministic JSON output, and parity checks across native and WASM targets.
Run Rust / WASM · Practise · Write a noteRust implementation
Follow a bounded JavaScript parser from source bytes through precedence and syntax trees, including unsupported syntax and useful diagnostics.
Run Rust / WASM · Practise · Write a noteRust implementation
Trace evaluation, mutable and constant bindings, function calls, DOM handles, and execution budgets through an explicit Rust runtime.
Run Rust / WASM · Practise · Write a noteRust implementation
Build a click path from Rust DOM nodes and trace listener invocation through capture, target, bubble, and propagation stopping.
Run Rust / WASM · Practise · Write a noteRust implementation
Follow event-driven DOM mutation through style, layout, and display-list generation while preserving node identity and observable evidence.
Run Rust / WASM · Practise · Write a noteRust implementation
Separate virtual time, timer handles, eligibility, and callback execution in the shared Rust runtime.
Run Rust / WASM · Practise · Write a noteRust implementation
Follow eligibility, tie breaking, callback completion, and deterministic replay of timer tasks.
Run Rust / WASM · Practise · Write a noteRust implementation
Inspect FIFO checkpoints, callbacks queued during draining, timer ordering, and bounded self-registration.
Run Rust / WASM · Practise · Write a noteRust implementation
Connect a click to timers, microtasks, DOM mutation, and explicit rendering opportunities.
Run Rust / WASM · Practise · Write a note
Put the parts together
Connect events, JavaScript, DOM, layout and paint to repair a broken page.
Repair the example, then verify it under different conditions.
Interactive experiments
Playback, prediction answers and repairs are tracked separately in this browser.
Parse a URL and follow a request and response using a local teaching fixture.
Loading…
Open demo →Connect source characters, tokens, the open-element stack and the growing tree.
Loading…
Open demo →Resolve competing declarations and inspect computed boxes and drawing output.
Loading…
Open demo →Follow parsing, bindings, function calls and return values.
Loading…
Open demo →Connect tree mutations with the event path and listener execution.
Loading…
Open demo →Inspect tasks, microtasks, rendering opportunities and invalidation.
Loading…
Open demo →Connect events, JavaScript, DOM, layout and paint to repair a broken page.
Loading…
Open demo →Build and run the Rust implementation
Rust / WASM execution
Run the same Rust core as WASM and inspect byte positions, tokens, DOM nodes and diagnostics.
Loading…
Local implementation (self-reported): Not recorded
Rust / WASM execution
Use the parsed DOM to inspect limited CSS rules, computed styles, boxes and drawing commands.
Loading…
Local implementation (self-reported): Not recorded
Run events and interrupts in Rust
Rust / WASM execution
Run a Rust lexer, parser and evaluator as WASM; inspect bindings, function calls, return values and DOM updates.
Loading…
Local implementation (self-reported): Not recorded
Rust / WASM execution
Deliver events through the same Rust DOM, inspect capture, bubbling and propagation stops, then recompute layout and paint.
Loading…
Local implementation (self-reported): Not recorded
Run reserved work and I/O in Rust
Rust / WASM execution
Reserve work from a click and inspect virtual time, deadlines, cancellation and task order alongside the same Rust DOM.
Loading…
Local implementation (self-reported): Not recorded
Rust / WASM execution
Follow enqueueing, draining and checkpoints, and observe the gap between a DOM mutation and committed paint.
Loading…
Local implementation (self-reported): Not recorded
My learning