Glossary

Terms used across all three tracks, with the precision the modules rely on. Where a definition is quoted or measured from the Chromium tree, the date is given — Chromium moves, and a stale definition is worse than none. See PROGRESS.md §7 for the verification log.

Browser architecture

Browser process — the privileged process. Owns UI, navigation, permissions, disk, cookies, and process allocation. Trusts nothing a renderer tells it.

Renderer process — sandboxed, hosts Blink and V8 for one or more same-site documents. Assumed to be compromised; this assumption generates most of Chromium's architecture.

GPU process — executes GL/Vulkan commands and runs the display compositor (viz). Isolated because graphics drivers are both fragile and a large attack surface.

Network service — owns sockets, TLS, and the HTTP cache. Renderers never hold a socket.

Blink — the rendering engine: HTML, DOM, CSS, style, layout, paint, events, Web APIs. Lives in third_party/blink/renderer. Not the same thing as "the renderer process".

V8 — the JavaScript and WebAssembly engine. A separate project. document is not a V8 concept; Node.js has V8 and no DOM.

cc — the compositor, in //cc. Runs in the renderer process, across the main thread and the compositor ("impl") thread. Not the GPU process.

viz — the display compositor, in the GPU process. Aggregates CompositorFrames from every renderer plus browser UI into the frame that is presented.

Mojo — Chromium's IPC system. A message pipe is a pair of endpoints; a .mojom file declares interfaces of messages; a Remote sends and a Receiver receives. Dispatch is a scheduled task, not a function call — ordering is guaranteed per pipe and not across pipes.

Associated interface — a Mojo interface sharing a pipe with a parent, which restores ordering between them. Seeing one usually means somebody was bitten by an ordering bug.

Process model (verified 2026-08-11, docs/process_model_and_site_isolation.md)

Site — scheme + eTLD+1 (https://example.com). Not an origin. a.example.com and b.example.com are the same site, because document.domain historically let them script each other synchronously.

SiteInfo — the security principal: what data an execution context may access.

SiteInstance — the principal instance, and the core unit of the process model. Any two documents with the same principal in the same browsing context group must share a process, because they have synchronous access to each other. Corresponds roughly (not exactly) to the HTML spec's agent cluster.

BrowsingInstance — the browsing context group: tabs and frames that can reach each other (window.opener, named targets, nested frames). rel="noopener" exists to keep a new page out of the group.

ProcessLock — the enforcement point. Restricts which sites may load in a RenderProcessHost and which data it may access. Granularity may be a site, an origin, a scheme, or "any site".

Site isolation — one renderer per site, including out-of-process iframes. Defends against a compromised renderer, not merely against script: after Spectre, "the data was never in that process" replaced "the checks stop it".

Rule of Two — code must not do all three of: process untrustworthy input, in an unsafe language, without a sandbox. Pick at most two. Explains most of Chromium's utility processes.

Rendering pipeline

Flat tree — the node tree with shadow content slotted in. Style and layout operate on this, not the node tree. Slot assignment does not change parentNode.

ComputedStyle — the fully-resolved property set for an element. Immutable and shared between elements that resolve identically; inline styles and unique selectors defeat the sharing.

RuleFeatureSet — the index built from stylesheets: for each feature (class, id, attribute, pseudo-class) it records what would need invalidating if that feature changed. Its entries are invalidation sets (descendant, sibling, nth, part/slotted), with a fallback to whole-subtree invalidation when precision is impossible.

invalidate: — a field in core/css/css_properties.json5 declaring, per property, which pipeline stage a change dirties. Measured 2026-08-11: 822 property entries, 311 declare it — 95 ["layout","paint"], 50 ["paint"], 34 ["layout"], 4 ["compositing"].

LayoutObject / LayoutBox — boxes participating in layout. Not one-per-element: display:none produces none, and anonymous boxes are synthesised.

ConstraintSpace — the immutable input to a layout algorithm (available size, fragmentation state, writing mode). Explicit inputs are what make layout results cacheable.

Fragment — an immutable geometry result. A box may produce several (pagination, multicol, inline splitting), which is why getClientRects() can return more than one rectangle.

Logical vs physical coordinates — layout thinks in inline/block, start/end; paint thinks in top/left. Code written physically breaks in RTL and vertical writing modes.

PrePaint — the phase that walks the layout tree to do paint invalidation and build paint property trees.

Display item — one recorded drawing command. Paint produces a recording, not pixels.

PaintChunk — "sequential display items that share a common property tree state". Change a property-tree node and the chunk's state changes while its contents do not — which is the entire transform/opacity fast path.

Property trees — four separate trees: transform, clip, effect, scroll. Separate so a scroll or a fade changes one node rather than re-recording the world.

Stacking context — an atomic unit of paint order. Created by opacity < 1, transform, filter, will-change, contain: paint, isolation, and others. Why opacity: 0.99 "fixes" z-index bugs.

Compositor (verified 2026-08-11, cc/README.md)

Layer / LayerImpl — the same concept on the main thread / the compositor thread. The type name tells you the thread.

Active tree — the layers and property trees used to submit a frame. Composited effects — scrolling, pinch, animation — are done by modifying the active tree, which is why they survive a blocked main thread.

Pending tree — the tree being rastered. Becomes active only when its tiles are ready, so half-rastered content is never shown.

CompositorFrame — a set of RenderPasses (lists of DrawQuads) plus metadata: instructions for drawing a scene, not pixels.

ElementID — a stable identifier across updates, used to attribute composited animations. The same role key plays in a reconciler.

Tile — a subdivision of a layer, rastered independently and prioritised by viewport proximity. Outrunning raster produces checkerboarding, which is deliberate: a consistent frame now beats a correct frame late.

Damage rect — the region that actually changed, so the GPU redraws only that.

Scheduling (verified 2026-08-11, platform/scheduler/TaskSchedulingInBlink.md)

Rendering opportunity — the point at which the browser runs rAF, observers, style, layout, paint, and commit. Not a task you can post.

Microtask checkpoint — drains the microtask queue exhaustively, including microtasks enqueued during the drain. Not a yield point: no rendering, no input.

Pausing — ScopedPagePauser enters a nested run loop during alert(), print(), or a debugger breakpoint. No JavaScript runs.

Deferring — tasks are deferred for 2 seconds after a user gesture, on the bet that another gesture is coming.

Freezing — background pages are frozen after 5 minutes on mobile; on desktop by heuristics based on which APIs the page uses.

Throttling — currently applies to JS timers only (setTimeout/setInterval).

INP — Interaction to Next Paint = input delay + processing + presentation. Two of the three terms are not your handler.

LoAF — Long Animation Frames API; reports long frames with blockingDuration and a scripts[] attribution.

Object lifetime

Oilpan — Blink's garbage collector, built on V8's cppgc. Heaps are per-thread; Node, CSSValue, and LayoutObject get dedicated typed spaces. Marking and sweeping are concurrent.

Unified heap — one collector tracing both the C++ and JavaScript heaps, which is what makes cross-heap cycles collectable. Supersedes "wrapper tracing"; TraceWrapperMember<T> no longer exists (verified 2026-08-11).

Member<T> / Persistent<T> / WeakMember<T> — graph edge / root from non-GC code / weak edge. An object's Trace() method is the authoritative list of what it keeps alive.

ActiveScriptWrappable — keeps an object alive while it has pending activity, because reachability alone would collect a pending XMLHttpRequest.

Wrapper — the JS object for a C++ DOM object. Created lazily, on first observation by script, and must be stable so expandos and === survive.

World (DOMWrapperWorld) — an isolated JS view of the same DOM, used for extension content scripts. Different wrappers, different expandos: a real security boundary.

Framework internals

Reconciliation — computing the minimal DOM operations between two descriptions of a UI.

Key — author-supplied identity for a list child. The runtime cannot infer it: [A,B,C] → [B,C] is ambiguous between "deleted A" and "renamed everything".

Fiber — an explicit, heap-allocated work-loop node (child / sibling / return) replacing the call stack, so render work can be paused, inspected, resumed, and discarded.

Render phase / commit phase — interruptible and side-effect-free / atomic and DOM-touching. Two statements of one requirement: discardable work must have done nothing, and output must be applied all at once.

Tearing — one render observing two different values of external mutable state. The reason useSyncExternalStore exists.

Glitch — a reactive system transiently computing a value from inconsistent inputs, e.g. a diamond a → b → d, a → c → d evaluated in the wrong order.

Invalidation set / dependency set — the same idea in a browser and in a reactive runtime: an index from "what changed" to "what must be recomputed".

Patch flag — a compiler-emitted annotation of which parts of a node can change, so the runtime skips comparisons. Compile-time knowledge substituting for runtime work.

Author-supplied guarantee — a promise the runtime cannot derive, which unlocks an otherwise impossible optimisation: key, {passive: true}, contain, sideEffects, aria-setsize, Origin-Agent-Cluster. This pattern recurs across every layer of the stack.