Topic domain
Web Platform
The browser as an execution environment and rendering engine.
- Articles
- 80
- Clusters
- 8
- Foundational
- 24
- Intermediate
- 32
- Advanced
- 24
Document structure and meaning.
- How the HTML Tokenizer and Tree Builder Recover from Malformed Markup
- Optional Tags and the Implied End Tag Rules the Parser Enforces
- HTML Content Model Categories and What They Actually Constrain
- Sectioning Content and the Heading Outline Browsers Never Implemented
- Constraint Validation and the Form Validity State Machine
- Accessible Name Computation: Which Attribute Wins
CSS Layout
10Box model, flow, flex, and grid.
- Adjoining Margins and the Block Formatting Context
- Used Values and the Containing Block
- Line Box Construction and the Inline Formatting Context
- Positioning and Stacking Contexts
- Intrinsic Sizing and Aspect Ratio
- Flex Basis, Free Space, and the Grow-Shrink Algorithm
Event loop, jobs, and module execution.
- Task Sources and the Ordering Guarantees of the Event Loop
- The Microtask Checkpoint and How Promise Jobs Actually Run
- Rendering Opportunities and When Animation Frame Callbacks Run
- Execution Contexts, Environment Records, and What a Closure Keeps Alive
- Object Shapes, Inline Caches, and the Cost of a Polymorphic Site
- Module Linking, Live Bindings, and the Order of Evaluation
Tree mutation, propagation, and observers.
- Node Identity and Structural Mutation in the DOM Tree
- Event Propagation: The Path, the Three Phases, and the Stop Flags
- Listener Identity, Options, and Removal During Dispatch
- MutationObserver Records, Batching, and Microtask Delivery
- Shadow DOM Boundaries and Event Retargeting
- Live Collections, Static Snapshots, and the Cost of Traversal
Critical path, layout cost, and paint.
- How a Frame Is Produced: Style, Layout, Paint, and Composite
- Render-Blocking CSS and Parser-Blocking Scripts on the Critical Path
- Layout Invalidation and Dirty Bits: Why Some Changes Reflow Everything
- Forced Synchronous Layout and the Cost of Interleaving Reads with Writes
- Compositing and Layer Promotion: When an Element Gets Its Own Layer
- Painting, Tiles, and Raster Cost: What a Repaint Actually Recomputes
Cookies, storage APIs, and caches.
- Storage Partition Keys and the Origin Boundary
- Cookie Scope and the Attributes That Restrict Sending
- The Synchronous Storage Contract of localStorage and sessionStorage
- Key Ordering and Cursor Semantics in IndexedDB
- Transaction Lifetime and Durability in IndexedDB
- Quota Accounting and Eviction Under Storage Pressure
Origins, CSP, and cross-site boundaries.
- How the Same-Origin Policy Computes and Compares Origins
- Cookie Scoping, SameSite, and the Site Boundary
- CORS Preflight, Credentials, and the Response Sharing Rules
- Content Security Policy: Source Lists, Nonces, and Trust Propagation
- Cross-Origin Isolation with COOP and COEP
- CSRF Defence: Synchronizer Tokens, Fetch Metadata, and SameSite
Service workers and offline behavior.
- Service Worker Lifecycle and the Registration Scope
- Fetch Event Interception and Response Construction
- Cache Storage Keys, Vary, and Cache Versioning
- Web App Manifest and the Installability Contract
- Offline Navigation, App Shell, and Fallback Routing
- Request Cloning and Body Streams in Fetch Handlers
All Web Platform articles
- Oct 14, 2026 Request Cloning and Body Streams in Fetch Handlers Why a fetch handler cannot both return a response and store it without cloning, how tee behaves under backpressure, and which bodies the Cache API refuses to store.
- Oct 12, 2026 Attributing Rendering Work: Reading Traces Without Guessing How to tell script time from style, layout, paint, and raster in a frame trace, which entry types expose the same information to code, and how to sample without fooling yourself.
- Sep 23, 2026 HTML Content Model Categories and What They Actually Constrain Flow, phrasing, sectioning, embedded, interactive, and transparent content describe what may nest inside what. Browsers enforce a few of those rules by repairing the tree and ignore the rest.
- Sep 20, 2026 Storage Partition Keys and the Origin Boundary How a browser derives the key that web storage is filed under, how scheme and port enter that key, and why partitioned third-party storage adds the top-level site.
- Sep 10, 2026 CORS Preflight, Credentials, and the Response Sharing Rules The request classifications that decide whether a preflight happens, what the OPTIONS exchange negotiates, and why credentialed CORS forbids the wildcard origin.
- Aug 19, 2026 Node Identity and Structural Mutation in the DOM Tree A DOM node is an object with one parent slot, and every insertion is a removal followed by an attach, with range adjustment, observer records, and adoption steps folded into that single call.
- Aug 6, 2026 Trusted Types and the Typing of DOM XSS Sinks How require-trusted-types-for turns string assignment into a checked operation, what a policy must do beyond returning its input, and how the enforcement spreads across a codebase without freezing releases.
- Jul 24, 2026 How Ranges Survive Mutation: Boundary Points and Live Updates A range is two boundary points that the DOM rewrites on every insertion and removal, and the adjustment rules explain both editing behaviour and the per-mutation cost of keeping ranges alive.
- Jul 18, 2026 The Microtask Checkpoint and How Promise Jobs Actually Run The mechanics behind promise callbacks: when the job queue drains, how await lowers to a reaction, and why a thenable resolution costs extra turns.
- Jul 13, 2026 How srcset and sizes Select an Image Resource Width and density descriptors describe the candidates, the sizes list converts layout into a pixel width, and the choice among candidates belongs partly to the browser.
- Jul 2, 2026 Alignment, Overflow, and Scroll Containers How alignment distributes free space inside a box, what overflow values do to the box model, and why one axis cannot stay visible when the other scrolls.
- Jun 17, 2026 Transaction Lifetime and Durability in IndexedDB Why an IndexedDB transaction commits without being asked, which callbacks keep it alive, how a failed request aborts the whole scope, and what the durability hint actually guarantees.
- Jun 16, 2026 Containment and Container Queries What each containment type isolates, why size containment is required for query containers, and how query units and content-visibility change the sizing of a subtree.
- Jun 8, 2026 How a Frame Is Produced: Style, Layout, Paint, and Composite The stages a browser runs between a DOM change and a changed pixel, which stages each kind of change can skip, and where the frame budget is actually spent.
- Jun 8, 2026 Web Push: Subscription, Encryption, and Delivery The four parties involved in a push message, how the aes128gcm envelope hides the payload from the push service, and which delivery headers decide whether a message is shown or dropped.
- Jun 3, 2026 Coordinating Tabs with Locks, BroadcastChannel, and Storage Events How Web Locks give same-origin tabs a queue per name, what BroadcastChannel does and does not deliver, and why the storage event cannot serve as a mutex.
- May 27, 2026 Content Security Policy: Source Lists, Nonces, and Trust Propagation How CSP directives fall back to default-src, why host allowlists leak through JSONP and open redirects, and how nonces plus strict-dynamic move script trust to runtime provenance.
- May 27, 2026 Key Ordering and Cursor Semantics in IndexedDB How IndexedDB compares keys of different types, why compound keys sort lexicographically, and how cursor direction and ranges decide which records a traversal visits.
- May 26, 2026 Cache API Match Semantics and Opaque Responses How a Cache decides whether a stored entry answers a request, what Vary does to lookup, and why opaque cross-origin responses cost quota without being readable.
- May 13, 2026 Realms, Cross-Realm Identity, and Errors That Cross Boundaries Each global object carries its own set of intrinsics, so objects from an iframe or worker fail instanceof checks while remaining fully usable and holding their realm alive.
- Apr 24, 2026 Cookie Scoping, SameSite, and the Site Boundary How cookies are addressed by host and path rather than of origin, what SameSite Lax and Strict actually permit, and where domain-scoped cookies leak across unrelated applications.
- Apr 6, 2026 Layout Invalidation and Dirty Bits: Why Some Changes Reflow Everything How a style change propagates into layout, where a reflow can be stopped at a layout root, and which changes defeat containment entirely.
- Mar 30, 2026 Adjoining Margins and the Block Formatting Context How block-level boxes stack in normal flow, when adjacent vertical margins merge into a single offset, and why establishing a formatting context stops the merging.
- Mar 15, 2026 CSS Containment and content-visibility: Skipping Rendering Work What contain: size, layout, style, and paint each guarantee, how content-visibility skips work for offscreen subtrees, and the scroll and accessibility edge cases.
- Feb 17, 2026 Structured Clone Across Storage Boundaries What the structured clone algorithm keeps when a value enters IndexedDB or crosses to a worker, which types it refuses, and how transfer differs from copying.
- Feb 16, 2026 Accessible Name Computation: Which Attribute Wins aria-labelledby, aria-label, label elements, alt text, and element content are consulted in a fixed order. The order, the recursion rules, and the roles that refuse a name entirely.
- Jan 27, 2026 Compositing and Layer Promotion: When an Element Gets Its Own Layer The rules that put an element on its own compositor layer, the memory each layer costs, and why promoting more elements can make a page slower instead of smoother.
- Jan 22, 2026 Fetch Event Interception and Response Construction How a service worker receives requests, what respondWith accepts, why a rejected promise produces an error page instead of a network fetch, and which requests never reach the handler.
- Dec 22, 2025 Service Worker Update Semantics and skipWaiting How byte comparison decides whether a new worker installs, what updateViaCache changes about that check, and why calling skipWaiting while old documents are open produces mixed-version clients.
- Dec 12, 2025 Live Collections, Static Snapshots, and the Cost of Traversal Query results differ in whether they track later mutations, and that difference decides whether iteration is safe and when a query pays for a full subtree walk.
- Oct 21, 2025 Service Worker Lifecycle and the Registration Scope How a service worker moves from registration through installation and activation, why a new version may wait indefinitely, and what the scope URL decides about the requests it can intercept.
- Oct 15, 2025 Intrinsic Sizing and Aspect Ratio What min-content, max-content and fit-content mean numerically, how replaced elements report their natural size, and how aspect-ratio transfers a definite dimension across axes.
- Oct 9, 2025 Resize and Intersection Observers: Delivery Inside the Rendering Update Both observers report geometry without polling, but they run at different points in the frame, and resize delivery can force a second layout that intersection delivery never causes.
- Sep 27, 2025 Shadow DOM Boundaries and Event Retargeting Events leaving a shadow tree carry a different target for each listener on the path, and the composed flag decides whether the path crosses the boundary at all.
- Sep 26, 2025 Rendering Opportunities and When Animation Frame Callbacks Run How the browser decides to paint a frame, what requestAnimationFrame is synchronized to, and why callbacks registered during a frame land in the next one.
- Sep 9, 2025 Cache Storage Keys, Vary, and Cache Versioning How the Cache API compares a request against stored entries, why HTTP freshness headers are inert inside it, and how cache names and activate-time deletion keep a deployment consistent.
- Sep 9, 2025 Cross-Origin Isolation with COOP and COEP How Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy combine to produce crossOriginIsolated documents, and what CORP must do on the other side of each load.
- Jul 31, 2025 Storage Quota, Persistence, and Eviction Why a cache that was written successfully can be gone on the next visit, how best-effort and persistent buckets differ, and what estimate() does and does not tell an application about its budget.
- Jul 30, 2025 Quota Accounting and Eviction Under Storage Pressure How browsers measure an origin's storage usage, where the quota figure comes from, what persistence changes, and how a victim is chosen when the disk fills.
- Jul 21, 2025 The Synchronous Storage Contract of localStorage and sessionStorage Why the Web Storage APIs expose a blocking string map, what that costs on the main thread, how storage events propagate, and where the quota boundary shows up.
- Jul 4, 2025 The Table Model, Foster Parenting, and Header Association Loose table markup is rebuilt into thead, tbody, and tr by the parser, stray content is moved out, and the header association algorithm decides which cell describes which.
- Jun 19, 2025 Web App Manifest and the Installability Contract How the manifest establishes an installed application identity through id, start_url, and scope, what display modes change at launch, and why installability is a browser policy rather than a specification rule.
- Jun 12, 2025 Forced Synchronous Layout and the Cost of Interleaving Reads with Writes Why calling getBoundingClientRect after a style write can trigger a full layout pass, how to recognise the pattern, and the restructuring that collapses N passes into one.
- Jun 12, 2025 Sectioning Content and the Heading Outline Browsers Never Implemented Nesting sections was meant to derive heading levels automatically. No engine shipped that, the algorithm left the standard, and headings now depend entirely on the level the author writes.
- May 20, 2025 Offline Navigation, App Shell, and Fallback Routing Why navigation requests need their own handling in a service worker, the trade between shell-based and per-URL caching, and how navigation preload removes the worker-startup delay from the critical path.
- Apr 25, 2025 Painting, Tiles, and Raster Cost: What a Repaint Actually Recomputes Display lists, invalidation rectangles, and tile rasterization: which changes force re-recording, which force re-rastering, and why blur and text dominate the bill.
- Apr 2, 2025 Template Contents, Slots, and Declarative Shadow DOM A template owns a document fragment that never enters the page, slots decide which light-DOM children render where, and a shadowrootmode attribute can attach a shadow root during parsing.
- Mar 13, 2025 Constraint Validation and the Form Validity State Machine Required, pattern, min, max, and step produce a set of independent validity flags, not one error. How the browser decides whether a form may submit, and where the API diverges from the interactive path.
- Feb 12, 2025 Positioning and Stacking Contexts How out-of-flow boxes resolve their offsets, which ancestor supplies their containing block, and how z-index orders boxes through nested stacking contexts.
- Dec 17, 2024 Subresource Integrity and the Trust Chain for Third-Party Scripts How the integrity attribute verifies fetched bytes, why cross-origin scripts need CORS for the check to run, and what hash pinning does and does not protect against.
- Dec 14, 2024 Line Box Construction and the Inline Formatting Context How inline-level boxes are packed into line boxes, what the strut contributes to line height, and why baseline alignment produces gaps that padding cannot remove.
- Dec 12, 2024 Optional Tags and the Implied End Tag Rules the Parser Enforces Only some tags may be omitted, and only where the tree builder already closes the element. The conformance conditions behind each omission, and the cases where leaving a tag out changes the tree.
- Dec 11, 2024 Structured Clone, Transferables, and the Worker Message Boundary What postMessage copies, what it moves, and where the cost lands: serialization on the sender, deserialization on the receiver, and shared memory behind isolation.
- Dec 4, 2024 Scrolling and the Compositor Thread: Why Scroll Handlers Break Smoothness How compositor-driven scrolling works, why a non-passive wheel listener forces the main thread into the loop, and which scroll-linked effects stay off it.
- Nov 29, 2024 Timer Clamping, Background Throttling, and Cooperative Yielding The integer arithmetic and nesting rules behind setTimeout, why intervals do not catch up, and how scheduler priority levels change when a callback runs.
- Nov 23, 2024 Frame Budgets, Long Tasks, and Where Input Latency Comes From How the main thread allocates work to a frame, why a 50 ms task delays the next interaction by more than 50 ms, and which scheduling primitives actually yield.
- Nov 15, 2024 Pointer Events: Capture, Coalescing, and the Hit-Test Boundary A pointer stream follows one device from down to up, and capture replaces hit testing as the routing rule while coalescing hides the samples the browser merged into a frame.
- Oct 25, 2024 Character Encoding Determination Before the Parser Runs A byte order mark, an HTTP charset parameter, and a meta prescan of the first 1024 bytes compete to decide how bytes become characters, and a late declaration can force a reparse.
- Oct 22, 2024 Writing Modes and Logical Properties How writing-mode rotates the inline and block axes, what direction changes about line layout, and why logical properties resolve against a different rectangle than their physical counterparts.
- Oct 9, 2024 Spectre, Site Isolation, and the Limits of the Origin Boundary Why speculative execution made the origin a weaker boundary than it appears, how process-per-site and response blocking reduce the exposure, and which timing channels remain open.
- Sep 16, 2024 Task Sources and the Ordering Guarantees of the Event Loop Why the browser runs callbacks from several independent queues, what ordering the specification actually promises, and where cross-queue assumptions break.
- Aug 5, 2024 Execution Contexts, Environment Records, and What a Closure Keeps Alive How identifier resolution walks a chain of environment records, why the per-iteration binding of let changes closure behaviour, and which storage a closure pins in memory.
- Aug 2, 2024 Event Propagation: The Path, the Three Phases, and the Stop Flags Dispatch walks a path computed before any listener runs, invoking capture listeners downward and bubble listeners upward, with separate flags for stopping traversal and cancelling the default action.
- Jul 12, 2024 How the Same-Origin Policy Computes and Compares Origins The origin triple of scheme, host, and port, the opaque origins produced by sandboxing and data URLs, and which browser capabilities the policy actually gates.
- Mar 6, 2024 How the HTML Tokenizer and Tree Builder Recover from Malformed Markup HTML error recovery is specified rather than improvised, which is why every engine builds the same tree from broken markup. The tokenizer states, the insertion modes, and the repair rules behind that guarantee.
- Feb 8, 2024 Used Values and the Containing Block How a declared width becomes a pixel length: which box the percentages resolve against, what box-sizing changes, and how auto margins and min-max constraints are resolved.
- Jan 17, 2024 Background Sync and Deferred Work How sync tags schedule retries after a failed request, why the payload must live in IndexedDB, and what the periodic variant does and does not guarantee about timing.
- Dec 20, 2023 Listener Identity, Options, and Removal During Dispatch Registrations are keyed by type, callback, and capture flag alone, so options like once and passive stick to the first registration, and removal criteria are narrower than most callers expect.
- Dec 11, 2023 MutationObserver Records, Batching, and Microtask Delivery Observers accumulate a record per mutation and deliver them once per microtask checkpoint, which coalesces bursts into a single callback and makes delivery timing a question about the event loop.
- Oct 4, 2023 Object Shapes, Inline Caches, and the Cost of a Polymorphic Site Why property access is fast when objects share a hidden class, how shapes transition, and what turns an inline cache from a lookup into a hash probe.
- Aug 1, 2023 Custom Element Reactions and Their Synchronous Callback Contract Lifecycle callbacks are queued reactions invoked at the end of the DOM operation that caused them, which makes them synchronous but batched, and explains upgrade ordering.
- Jul 13, 2023 Sandboxed Frames and the postMessage Trust Boundary Which capabilities the sandbox attribute strips and which tokens restore them, why allow-scripts with allow-same-origin defeats the frame, and how to validate a message without racing a navigation.
- Jun 12, 2023 CSRF Defence: Synchronizer Tokens, Fetch Metadata, and SameSite Why ambient credentials make state-changing requests forgeable, what a synchronizer token must be bound to, and how Sec-Fetch-Site lets a server reject cross-site writes without per-form state.
- Jan 13, 2023 Cookie Scope and the Attributes That Restrict Sending How the Domain and Path attributes decide which requests carry a cookie, and how Secure, HttpOnly, and expiry constrain what can be done with it once stored.
- Dec 19, 2022 Flex Basis, Free Space, and the Grow-Shrink Algorithm How a flex container assigns base sizes, computes free space along the main axis, and resolves growth and shrinkage when items are clamped by minimums.
- Nov 2, 2022 Render-Blocking CSS and Parser-Blocking Scripts on the Critical Path Why a stylesheet stops the first paint and why a script stops the parser, which dependencies the preload scanner can find on its own, and what defer and async actually order.
- Sep 19, 2022 Grid Track Sizing and the fr Unit How the grid algorithm sizes tracks from intrinsic contributions, why 1fr has an automatic minimum, and how auto-placement fills the implicit grid.
- Sep 11, 2022 Module Linking, Live Bindings, and the Order of Evaluation ECMAScript modules resolve and instantiate the whole graph before running a single statement, which is what makes imports live and cycles behave unlike CommonJS.
- Dec 16, 2021 Dynamic Import, Module Maps, and Top-Level Await What import() actually schedules, how the module map keys records by URL, and why top-level await turns a synchronous graph into an asynchronous one.
- Nov 25, 2021 The Origin Private File System and Synchronous Access Handles How OPFS exposes a private per-origin directory tree, what an exclusive sync access handle offers a worker, and where byte-addressable storage beats record stores.