Is Ladybird Rust Yet?

Is Rust Profitable Yet?
Last updated on 12:00AM on September 13, 2026 (TZ: UTC+0000)

Individual commit stats

LibWeb: Derive and retain layout styles in Rust

LibWeb: Invalidate overflow when Rust receives changed styles

LibWeb: Refresh scrollable overflow behind Rust geometry queries

LibWeb: Keep scrollable overflow caches in Rust-owned storage

LibWeb: Share the partial relayout entry for SVG and abspos boxes

LibWeb: Read saved abspos inputs from committed fragment links

Tests: Create proper dependency tracking for Rust/Flap tests

LibWeb: Remove unused layout arena FFI exports

LibWeb/CSS: Remove unused inline CSS helpers

LibWeb/CSS: Remove unused ComputedValues builder methods

LibWeb/CSS: Remove unused attribute token splitting helper

LibWeb/CSS: Remove unused computed style data structs

LibWeb/CSS: Remove uncalled CSS helper functions

LibWeb/CSS: Remove unused standalone media condition evaluator

LibWeb: Remove unused CSSAnimation::cancel_from_css

LibWeb/CSS: Remove unused EasingFunction::to_style_value

LibWeb/CSS: Remove dead computed style working set methods

LibWeb/CSS: Remove unused QueryValueType and CharacterTypes headers

LibWeb: Collect scroll snap geometry in Rust

LibWeb: Split scroll snap position selection from its layout geometry

LibWeb: Remove the basic shape facade

LibWeb: Remove the unused anchor-size facade

LibWeb: Remove light-dark and contrast color facades

LibWeb: Update the Rust serialization ownership test

LibWeb: Remove unused style value facades

LibWeb: Remove empty style value facades

LibWeb: Move color function equality to Rust

LibWeb: Remove duplicate color function resolution

LibWeb: Remove the selector text FFI wrapper

LibWeb: Remove the serialized text FFI wrapper

LibWeb: Move linear easing canonicalization to Rust

LibWeb: Remove unused CSS serialization helpers

LibWeb: Finish moving color-mix resolution to Rust

LibWeb: Remove unused CSS parser error type

LibWeb: Report which style changes alter the hit-test display list

LibWeb: Drop the scroll registry from the viewport recommit in Rust

LibWeb: Invalidate the scroll state where scroll offsets are stored

LibWeb: Verify skipped scroll state refreshes on request

LibWeb: Publish the scroll state snapshot from its refresh

LibWeb: Resolve sticky offsets inside the Rust scroll state refresh

LibWeb: Let the Rust scroll state own its dirty bit

LibWeb: Drop the redundant scroll state refreshes

LibGfx: Share the shaping cache with C++ text callers

LibWeb: Test repeated canvas text across drawing state changes

LibWeb: Remove the unused C++ mask compositing conversion

LibWeb: Remove the unused C++ PaintPhase enum

LibWeb: Remove unused box overflow accessors

LibWeb: Remove unused SVG paintable predicates

Meta: Compile Rust tests as part of the default build

LibWeb: Include style-replay in default builds on POSIX systems

Meta: Allow running existing binaries without building

Documentation: Add a runnable WebDriver investigation example

RequestServer: Allow mapped resource files through the Linux sandbox

Meta: Add a reader for saved test-web results

LibWeb: Share the image paint fact payloads

LibWeb: Record display lists without host callback tables

Tests: Pin repaints after SVG paint server mutations

LibWeb: Build SVG pattern paint styles from published descriptions

LibWeb: Build SVG gradient paint styles from published descriptions

LibWeb: Publish resolved SVG filters before the visual context update

LibWeb: Resolve the SVG clip area in Rust

LibWeb: Resolve the SVG masking area in Rust

LibWeb: Relayout elements referencing a mutated mask or clipPath

LibWeb: Commit the additional SVG element transform at layout

LibWeb: Commit video paint facts

LibWeb: Resolve SVG image display lists after the recording

LibWeb: Commit replaced image paint facts

LibWeb: Draw layer image frames from Rust-owned handles

LibWeb: Commit layer image paint facts

LibWeb: Push navigable container paint facts before recording

LibWeb: Commit canvas paint facts

LibWeb: Commit form control paint facts

LibWeb: Commit ::selection styles to the layout arena

LibWeb: Derive async scroll metadata from committed arena state

LibWeb: Resolve scroll node identities in the visual context update

LibWeb: Move scroll snap axis selection into Rust

LibWeb: Derive line-break caret targets from committed lines

LibWeb: Remember the forced break node that ended each line

LibWeb: Drop the recorder's paintable DOM facts callback

LibWeb: Take SVG mask and clip content units from committed layout facts

LibWeb: Stamp blocking wheel handler containment into layout node data

LibWeb: Stamp editability into layout node data

LibWeb: Publish the recording's fonts after the walk

LibWeb: Stamp DOM inertness into layout node data

LibWeb: Take the recording trace from Rust after the recording

LibWeb: Repaint form controls on indeterminate and disabled changes

LibWeb: Read local background scroll offsets from the Rust scroll state

LibWeb: Align CSS custom function evaluation with the spec

LibWeb: Include function identity in property substitution contexts

LibWeb: Use shared guarded substitution contexts

LibWeb: Rename `VarResolutionContext` to `ASFResolutionContext`

AK: Add a Rust ScopeGuard

LibTextCodec: Use the mimalloc-backed Rust allocator

LibWeb: Remove redundant Rust style bridge

LibWeb: Borrow stylesheet rule and media list views

LibWeb: Remove duplicate collection style value owners

LibWeb: Resolve easing, shapes and gradients in Rust

LibWeb: Serialize CSS values and grid results directly in Rust

LibWeb: Consume Rust rule graphs through lazy CSSOM wrappers

LibURL: Parse borrowed native ASCII and UTF-16 input

AK: Allocate Rust data without C++ forwarding calls

LibWeb: Own CSS descriptors in Rust and expose wrappers lazily

LibWeb: Own CSS declaration blocks and mutation state in Rust

LibWeb: Parse and share downloaded stylesheets on workers

LibWeb: Own thread-shareable CSS values and selectors in Rust

LibWeb: Remove the C++ formatting context type helpers

LibWeb: Port the layout tree dump to Rust

LibWeb: Drop the unused show_computed_properties layout dump option

AK: Capture Rust panic diagnostics in crash reports

LibWebView: Expose crash reports in native overlays and settings

LibWebView: Save local helper crash reports on macOS and Linux

UI/AppKit: Report every select dropdown close to WebContent

UI/Qt: Report every select dropdown close to WebContent

LibGfx: Answer single glyph advances from the Rust shaping cache

LibGfx: Fold the retained font reference into FontEntry

LibWeb: Paint text through FontHandle and delete the borrowed font views

LibWeb: Carry fonts through layout as FontHandle values

LibGfx: Add FontHandle, an owned Rust view of a Gfx::Font

LibWeb: Key the text chunk cache on an owned font cascade list handle

LibWeb: Stop pinning font cascade lists for style records

LibWeb: Make the engine's font resolver cache own its cascade lists

LibWeb: Let the font style group own its font cascade list

LibWeb: Read the font style group through FontValues

LibWeb: Resolve per-document paint facts once per display list recording

LibWeb: Decide viewport style propagation on the Rust side

LibWeb: Recompute containing blocks inside Rust tree build and layout

LibWeb: Keep the partial relayout escape bit in the layout arena

LibWeb: Reset layout flags and overflow bookkeeping inside Rust layout

LibWeb: Reuse dispatch scratch when selecting transpose waypoints

LibWeb: Reuse parent dispatch scratch during transpose analysis

LibWeb: Merge retained match survivors when materializing patches

LibWeb: Use exact iterator lengths for live interned identities

LibWeb: Read shared-style inheritance flags only on insertion

LibWeb: Recognize shared group sets in record inheritance checks

LibWeb: Reuse the environment lookup in parent inheritance checks

LibWeb: Defer routing registry setup until an input has keys

LibWeb: Build small input routing key lists inline in one pass

LibWeb: Split full posting chunks before inserting new nodes

LibWeb: Reserve once when collecting posting candidates

LibWeb: Check dash-match boundaries before comparing prefixes

LibWeb: Return cached sibling prefix answers without republishing

LibWeb: Call the sibling prefix matcher directly

LibWeb: Read sibling sequence heads only when starting a prefix

LibWeb: Keep short descendant relation walks inline

LibWeb: Skip cascade repair for removed losing declarations

LibWeb: Keep incremental cascade repair targets inline

LibWeb: Reuse rule priorities during incremental cascade repair

LibWeb: Keep cascade winner publication target lists inline

LibWeb: Keep cascade compaction pseudo targets inline

LibWeb: Avoid sorting winners just to mark retained cascade rules

LibWeb: Skip subtree membership checks for walked query candidates

LibWeb: Keep partial style rebuild group identities inline

LibWeb: Read only property IDs when computing inherited group masks

LibWeb: Skip shared winner groups when comparing property shapes

LibWeb: Reuse saved primary facts when staging element edits

LibWeb: Reuse attribute query candidate vector storage

LibWeb: Reuse matched dispatch keys in direct rule filtering

LibWeb: Skip deduplicating single-posting query candidates

LibWeb: Reuse staged part and custom-state vector storage

LibWeb: Keep the first sibling type counter inline

LibWeb: Track positional answer capacity incrementally

LibWeb: Borrow sibling type position storage once per sequence

LibWeb: Keep simple query candidate cache probes inline

LibWeb: Compare case-sensitive attribute filter values as slices

LibWeb: Compare case-sensitive selector text as slices

LibWeb: Skip cascade sorting for single dispatch candidates

LibWeb: Check written attribute names first in optimized matching

LibWeb: Reuse the reserved empty prefix result

LibWeb: Reuse reserved empty prefix set identities

LibWeb: Reject prefix attribute value mismatches before name lookup

LibWeb: Skip hashing the implicit unlayered cascade bucket

LibWeb: Skip attachment lookup for document cascade contexts

LibWeb: Avoid duplicate attribute alias dispatch probes

LibWeb: Keep the subtree collector root worklist inline

LibWeb: Bound cascade update reservations by winner group size

LibWeb: Reuse materialized winners when comparing cascade updates

LibWeb: Keep common pseudo-state copy scratch inline

LibWeb: Match written attribute names before loading aliases

LibWeb: Append empty before-state facts directly for new elements

LibWeb: Reuse the staged row borrow throughout fact edits

LibWeb: Skip fact column growth checks for existing elements

LibWeb: Append staged attributes directly to the fact payload

LibWeb: Borrow element facts while removing selector postings

LibWeb: Read resident facts directly when removing atom references

LibWeb: Borrow staged selector facts while committing them

LibWeb: Iterate staged first-child links without copying them

LibWeb: Reduce pseudo-element cascade matching overhead

LibWeb: Reuse attribute lookups when updating style facts

LibWeb: Reuse declaration block ordering during cascade resolution

LibWeb: Track selector incidence payload bytes incrementally

LibWeb: Keep single slotted and part matching scopes inline

LibWeb: Calculate rule compaction priorities only when needed

LibWeb: Keep temporary cascade state groups inline

LibWeb: Keep small multi-key selector deduplication lists inline

LibWeb: Keep single shadow part exposure hosts inline

LibWeb: Combine sibling type counts into one position vector

LibWeb: Reuse element declaration priorities during compaction

LibWeb: Keep inherited group replacement scratch inline

LibWeb: Reuse custom property cascade ordering within each block

LibWeb: Reuse stylesheet attachments when finding cascade context

LibWeb: Drain grown selector postings without a temporary vector

LibWeb: Short-circuit custom property match scans

LibWeb: Consume feature flux entries when building the reverse index

LibWeb: Skip radix sorting already ordered dirty node batches

LibWeb: Check pseudo substitution usage without collecting states

LibWeb: Avoid retaining font families on font cache hits

LibWeb: Preserve sorted cascade winners when appending ordered keys

LibWeb: Skip copying unchanged animation name sets

LibWeb: Transfer completed selector truth out of match scratch

LibWeb: Avoid materializing initial style winner deltas

LibWeb: Stop checking cascade completeness after an incomplete rule

LibWeb: Avoid allocating duplicate cascade provenance groups

LibWeb: Lower animation and canvas filter functions on the Rust side

LibWeb: Build SVG filter graphs on the Rust side

LibGfx+LibWeb: Keep Gfx::Filter as its serialized bytes

LibWeb: Resolve only the url() part of a filter list on the C++ side

LibWeb: Lower CSS filters through the shared Rust filter codec

LibGfx: Add a Rust filter graph with the serialized filter codec

LibWeb: Remove the unused C++ property invalidation classifier

LibWeb: Pass previous paintable offsets through layout commit

LibWeb: Consolidate broad style plans against retained answers

LibWeb: Append already ordered retained match answers directly

LibWeb: Resolve incidence prefix entries outside candidate loops

LibWeb: Avoid redundant selector incidence setup

LibWeb: Select current selector incidences in place

LibWeb: Scan rules once for removed selector programs

LibWeb: Store custom property environment keys in boxed slices

LibWeb: Reserve custom property results from the known name count

LibWeb: Remove duplicate priority storage from cascade contenders

LibWeb: Narrow contender scans while resolving revert chains

LibWeb: Select ordinary cascade winners without sorting contenders

LibWeb: Skip replaced group lookups during inherited style updates

LibWeb: Load winner provenance only after finding the property

LibWeb: Reject weaker cascade additions before searching updates

LibWeb: Check cascade continuation identities without loading payloads

LibWeb: Reuse retained winners during cascade property updates

LibWeb: Use pending winner priorities during cascade updates

LibWeb: Reuse matched rules across cascade property updates

LibWeb: Defer winner lookups until cascade repair needs them

LibWeb: Reuse preceding sibling parent identity lookups

LibWeb: Reuse part host list storage when updating elements

LibWeb: Resolve sole custom property candidates without grouping

LibWeb: Serialize benchmark marker names without copying them

LibWeb: Reuse custom property cascade ceiling storage

LibWeb: Drop redundant custom property candidate order indices

LibWeb: Borrow custom property values while resolving the cascade

LibWeb: Check foldable input kinds before searching arrivals

LibWeb: Find declaration changes in sorted transaction inputs

LibWeb: Merge repaired winners with requested properties linearly

LibWeb: Reuse selector operands across scope compilation levels

LibWeb: Compile selector argument lists directly to disjunctions

LibWeb: Compile single has arguments without an alternatives buffer

LibWeb: Reuse operands while compiling part selectors

LibWeb: Reuse prefix compound and step insertion lookups

LibWeb: Allocate semantic winner groups only on interning misses

LibWeb: Reuse winner merge buffers across property groups

LibWeb: Skip preorder ranking for empty selector candidates

LibWeb: Update retained witnesses through a single lookup

LibWeb: Stream declaration inventories into dispatch storage

LibWeb: Store cached attribute and language text as boxed slices

LibWeb: Flatten routing directories without sorting keys

LibWeb: Keep selector program storage slots compact

LibWeb: Reuse shared selector bucket lookups during cleanup

LibWeb: Borrow display values during pseudo-style admission

LibWeb: Skip shared group payload walks during record comparison

LibWeb: Check cheap table metadata before comparing style values

LibWeb: Skip property shape walks for identical cascade states

LibWeb: Short-circuit identical states in cascade delta iteration

LibWeb: Retain written cascade values only when needed

LibWeb: Borrow written values when checking record sharing

LibWeb: Move staged sheet orders into the rule program

LibWeb: Reuse property lists for repeated declaration edits

LibWeb: Skip count-map borrowing for empty atom pin guards

LibWeb: Reuse global atom lookups when releasing final references

LibWeb: Use sorted atom membership during sweep cleanup

LibWeb: Skip atom sweep work when nothing is reclaimable

LibWeb: Avoid allocating a span vector for a single scope

LibWeb: Compact immutable selector dispatch metadata storage

LibWeb: Build compound operands directly in program storage

LibWeb: Stream language ranges into the selector builder

LibWeb: Reuse the lookup when releasing a style record pin

LibWeb: Compact atom pin guards and reuse release lookups

LibWeb: Reuse the inheritance dependency view buffer

LibWeb: Skip discarded dependency copies when seeding a full drive

LibWeb: Avoid recopying partial-drive inheritance dependencies

LibWeb: Compact retained custom property memo values

LibWeb: Reorder selector prefix arrays in place

LibWeb: Simplify region batch cache insertion

LibWeb: Stream winning nodes into program impact regions

LibWeb: Walk child reactions without copying child lists

LibWeb: Store immutable custom property names as boxed slices

LibWeb: Collect only unreachable computed identities for reclamation

LibWeb: Deduplicate selector dispatch alternatives in place

LibWeb: Remove duplicate hashes from cascade winner groups

LibWeb: Iterate cascade property deltas without temporary lists

LibWeb: Store immutable cascade lists as boxed slices

LibWeb: Avoid an intermediate allocation for short match answers

LibWeb: Compare cascade semantics through interned winner groups

LibWeb: Avoid redundant work when replaying retained answers

LibWeb: Short-circuit active transition property checks

LibWeb: Avoid redundant retained style-value clones

LibWeb: Look up ASCII property names without UTF-16 buffers

LibWeb: Hash inheritance-dependent values without copying or sorting

LibWeb: Reuse compiled subject dispatch keys when building scopes

LibWeb: Remove the unused single-key dispatch analysis mode

LibWeb: Avoid temporary payload vectors in computed style updates

LibWeb: Borrow parent payloads when assembling computed style records

LibWeb: Move old part and custom-state vectors when replacing them

LibWeb: Avoid copying and rescanning previous animation names

LibWeb: Borrow current sheet lists for read-only operations

LibWeb: Detect sheet attachment reorders by position

LibWeb: Restore reattached sheet routes without temporary pairs

LibWeb: Iterate selector incidence candidates directly

LibWeb: Borrow selector incidence cache entries during lookup

LibWeb: Iterate staged tree relations without temporary vectors

LibWeb: Merge retained patch rule selections in place

LibWeb: Store retained patch rule identities only once

LibWeb: Capture staged program snapshots only on the first edit

LibWeb: Consume dispatch buckets when building their directory

LibWeb: Group dispatch cascade ranks with slice chunks

LibWeb: Read prefix flags directly when rebuilding dispatch indexes

LibWeb: Build ancestor dispatch shapes directly in index order

LibWeb: Forget retired atom postings without temporary keys

LibWeb: Record evicted posting keys without temporary storage

LibWeb: Check posting admission before probing existing keys

LibWeb: Take retained prefix relations with one cache lookup

LibWeb: Stream bounded child prefixes during positional routing

LibWeb: Collect sibling route candidates without temporary origins

LibWeb: Share routing site construction

LibWeb: Skip clearing sequence index pages before rewriting them

LibWeb: Simplify lazy sibling-position index initialization

LibWeb: Reuse the retained posting lookup during planning

LibWeb: Reuse stored inherited-group identities in record assignment

LibWeb: Reuse map entries when updating pseudo computed rows

LibWeb: Share computed group payload interning

LibWeb: Share fixed metadata interning between computation paths

LibWeb: Compare inherited group payloads without identity round trips

LibWeb: Build top-down walk paths directly from sibling ordinals

LibWeb: Borrow committed sheet lists when reading scope programs

LibWeb: Check sheet attachment changes without temporary scope lists

LibWeb: Collect sheet departures once when building staging deltas

LibWeb: Skip clean staged fields when collecting updates

LibWeb: Use map entries when staging program fields

LibWeb: Invalidate sheet-dependent scopes without temporary storage

LibWeb: Retire inactive scope programs without temporary storage

LibWeb: Collect old declaration properties only for the first edit

LibWeb: Reuse computed layer ranks when checking for order changes

LibWeb: Use map entries when assigning cascade layer ranks

LibWeb: Reuse the semantic declaration bucket during interning

LibWeb: Share subtree detachment between rule removal paths

LibWeb: Sort collected sheet rules by their order ranks

LibWeb: Compute selector entry properties without temporary storage

LibWeb: Simplify element-declaration winner repair preparation

LibWeb: Reuse normalized input order when collecting arriving nodes

LibWeb: Remove redundant reservation before extending match answers

LibWeb: Simplify selector-program insertion helpers

LibWeb: Remove unused counters from indexed sibling-position lookup

LibWeb: Remove unused counters from journal memory settlement

LibWeb: Remove the duplicate intern-table emptiness test helper

LibWeb: Use map entries when registering custom-property data

LibWeb: Reuse the hash map entry when inserting feature postings

LibWeb: Compare inheritance-dependent values without temporary vectors

LibWeb: Derive the default cascade order state

LibWeb: Share content hashing across style interners

LibWeb: Remove unused counters from prefix-state helpers

LibWeb: Simplify impact-region insertion and attribution

LibWeb: Remove unused counters from program memory settlement

LibWeb: Remove the unused catalog from prefix memory accounting

LibWeb: Group sorted style entries with slice chunks

LibWeb: Release match answers without temporary storage

LibWeb: Use column operations for answer lanes and winner stamps

LibWeb: Match prefix-state cache entries directly

LibWeb: Intern non-prefix match answers directly

LibWeb: Share document atom initialization

LibWeb: Share paged column allocation during insertion

LibWeb: Advance sorted merges through their remaining slices

LibWeb: Avoid repeated lookups when inserting cascade winners

LibWeb: Store cascade order labels directly

LibWeb: Derive style catalog identities from storage lengths

LibWeb: Derive specified-value pointer keys from retained values

LibWeb: Store specified-value coverage gaps directly

LibWeb: Remove the unused layer identity from priority inputs

LibWeb: Remove redundant specified-value lookup probes

LibWeb: Use scalar ranks in the Rust style engine cascade

LibWeb: Centralize stylesheet resource base URL lookup

LibWeb: Maintain selector prefix memberships across style updates

LibWeb: Preserve rule attribution without preorder coordinates

LibWeb: Exclude inactive rules from prefix match deltas

LibWeb: Retain shared computation contexts in the style engine

LibWebView: Keep crashed clients alive while notifying views

LibWeb: Reuse unchanged pseudo styles during C++ fallback

LibWeb: Avoid redundant work when propagating inherited style inputs

LibWeb: Publish substitution usage with engine-computed records

LibWeb: Share box transformation input construction in Rust

LibWeb: Separate style record driving and pseudo publication

LibWeb: Resolve custom properties and share engine-computed records

LibWeb: Settle inherited and cold records in the style engine

LibWeb: Extend engine-computed records across style reactions

LibWeb: Compute initial style records in the style engine

LibWeb: Use native text sources and ranges for first-letter processing

LibWeb: Map rendered text queries to DOM ranges in Rust

LibWeb: Refresh rendered text directly in Rust

LibWeb: Store text chunks in the rendered text snapshot

LibWeb: Own first-letter text slices in the Rust arena

LibWeb: Own rendered text cache validity in Rust

LibWeb: Build rendered text in Rust

LibWeb: Keep rendered text and offset mapping in the Rust arena

LibWeb: Scope layout borrows and make paint mutation explicit

LibWeb: Skip command capture for empty paint phases

LibWeb: Retain inherited group identities in shared style records

LibWeb: Read generated content from its retained style value

LibWeb: Size empty inline-block boxes in their parent layout run

LibWeb: Publish initial element features in node identity order

LibWeb: Walk the containing block scroll chain in Rust

LibWeb: Decide compositor animation offscreen clipping in Rust

LibWeb: Collect content-visibility: auto boxes in Rust

LibWeb: Walk the fixed-position containing block chain in Rust

LibWeb: Map Range text rects to the viewport in Rust

LibWeb: Compute the intersection observer clip chain in Rust

LibWeb: Compute Element client rects in Rust

LibWeb: Decide the getClientRects fast path in Rust

LibWeb: Make the force-dark performance numbers reproducible

LibWeb: Test that force-dark leaves the line-box overlay alone

LibWeb: Judge borders/selections against the force-dark’ened backdrop

LibWeb+LibWebView: Add a force-dark setting to about:settings

LibWeb: Teach force-dark which images to invert (and which not to)

LibWeb: Wire force-dark through the display-list recorder

LibWeb: Keep the color-scheme “only” flag a meta tag declares

LibWeb: Add the color engine for force-dark mode

LibWeb: Drive CSS filter animations from the compositor

LibWeb: Materialize anonymous layout shells on first use

LibWeb: Key layout arena liveness on the slot instead of the shell

LibWeb: Reinherit anonymous box styles through the layout arena

LibWeb: Create anonymous layout boxes in the Rust tree builder

LibWeb: Split layout slot allocation from shell binding

LibWeb: Derive anonymous box styles from a parent style record

LibWeb: Add GC tests for layout-rooted DOM nodes

LibWeb: Root layout DOM nodes from the document instead of each shell

LibWeb: Tear down the layout tree when a document is finalized

LibWeb: Pin layout style records without rooting the document

LibWeb: Resolve a layout node's document through its arena

LibWeb: Record each layout node's DOM node in the arena

LibWeb: Fold the layout node's arena slot into the node itself

LibWeb: Add layout-tree teardown tests for deep and top-layer subtrees

LibWeb: Let the layout node arena own its C++ shells

LibWeb: Stop holding layout nodes by reference outside the arena

LibWeb: Free layout subtrees from the arena in one walk

LibWeb: Hand out NodeData references inside the layout node arena

LibWeb: Stop sharing NodeData between the arena and the node shell

LibWeb: Read layout node facts from the arena instead of the shared slot

LibWeb: Route layout node writes from the shell through the arena

LibWeb: Pass layout node construction facts into the arena allocation

LibWeb: Drop the redundant slot generation from the arena allocation

LibWeb: Drop the abort_on_panic wrappers from the FFI entry points

LibWeb: Eliminate animation overlay mirrors

LibWeb: Reuse font metrics during animation sampling

LibWeb: Diff animation overlays directly in Rust

LibWeb: Use a regular map for animation update state

LibWeb: Seed animation updates from style records

LibWeb: Read display-none state from style records

LibWeb: Keep animation sampling on overlays

LibWeb: Reuse animation preparation across samples

LibWeb: Avoid cloning unrelated animation keyframe longhands

LibWeb: Hand overlay node labels to Rust as UTF-8 bytes

LibWeb: Share the CSS filter serialization between both filter hosts

LibWeb: Return the visual context update outcome as the FFI struct

LibWeb: Reuse the visual context tree inputs when recording

LibWeb: Resolve painting dump owner labels on the Rust side

LibWeb: Let Rust pick the visual context nodes an animation can target

LibWeb: Map scroll snap area rects through CSS transforms in Rust

LibWeb: Hand mask display list registrations over with the recording

LibWeb: Let the Rust image paint recorder resolve gradients itself

LibWeb: Skip selector matching for querySelectorAll("*")

LibWeb: Build static node lists from GC::RawRef vectors

LibWeb+UI: Support pasting images into editable DOM nodes

LibWebView+UI: Change return type of clipboard accessor function

LibWeb: Allow copying HTML::SelectedFile

LibWeb: Implement modulepreload processing

LibWeb: Align module script fetching with HTML

LibWeb: Keep content sync enrollment in the node arena

LibWeb: Gate container query size changes in the commit

LibWeb: Collect eager overflow measurement roots in Rust

LibWeb: Run the scrollable overflow update inside the arena

LibWeb: Classify layout tree updates through one arena call

LibWeb: Shrink the layout shell surface

LibWeb: Answer three small paintable queries from Rust

LibWeb: Retire dead style FFI exports and the ABI anchor idiom

LibWeb: Fold the duplicated visibility expression in BoxViews

LibWeb: Answer positioning and transform queries from Rust

LibWeb: Delete dead layout and painting code

LibWeb: Delete FFI exports whose C++ callers are gone

LibWeb: Keep the scrollable overflow queue in the node arena

LibWeb: Collect partial relayout boundary roots in Rust

LibWeb: Port the saved abspos replay validity check to Rust

LibWeb: Invalidate paint caches inside the paintable clear

LibWeb: Reset intrinsic size caches through the node arena

LibWeb: Reset partial relayout flags through the existing arena walk

LibWeb: Delete the unread HasBeenWrappedInTableWrapper flag

LibWeb: Port layout update marking to Rust

LibWeb: Keep partial relayout roots in the node arena

LibWeb: Port partial relayout boundary check to Rust

LibWeb: Stamp document-element identity on layout nodes

LibWeb: Store default scroll shift anchors in the Rust layout arena

LibGfx: Delete the C++ shaping cache

LibWeb: Shape inspector overlay labels through the Rust text pipeline

LibGfx: Move the shaping cache for Rust layout callers into Rust

LibGfx: Shape text for Rust callers without materializing a GlyphRun

LibWeb+LibGfx: Stop retaining a C++ GlyphRun for paintable fragments

LibWeb: Use the libgfx DrawGlyph type through layout and painting

LibWeb: Port the stacking context dump to Rust

LibWeb: Port the display list dump to Rust

LibWeb/Painting: Bound scroll-state indices by the node count

LibWeb: Record the display list from the incremental stacking contexts

LibWeb: Maintain stacking context entry tables incrementally

LibWeb: Label layout nodes in pre-order

LibWeb: Note stacking context style changes on the affected box

LibWeb: Record stacking context facts with the visual context records

LibWeb: Delete the C++ visual context tree mirror

LibWeb: Answer every visual context tree query from Rust

LibWeb: Compute display list damage in Rust

LibWeb: Drive display list replay from Rust

LibWeb: Serialize visual context trees through Rust

LibWeb: Give the C++ visual context tree a Rust-owned handle

LibWeb: Send visual context tree filter images as display list resources

LibWeb: Serialize visual context trees to bytes in Rust

LibWeb: Port the visual context tree queries to Rust

LibWeb: Create cursor bitmap visual context trees in Rust

LibWeb: Build background tile visual context trees in Rust

LibGfx: Add shared system font catalog support

LibCore: Map anonymous buffers with MappedFile on Windows

LibWeb: Truncate calculated length-percentage used values

Tests/LibWeb: Add an end-to-end AIA certificate-fetching test

Tests/RequestServer: Add unit tests for AIA certificate parsing

RequestServer: Implement AIA fetching, for sites with broken cert chains

LibCrypto+LibTLS: Add an OpenSSL_X509 wrapper class

LibGfx: Remove the C++ BSP tree superseded by the Rust port

LibWeb: Build the depth-sorted replay plan in Rust

LibWeb: Port the depth-sorted replay plan builder to Rust

LibWeb: Answer hit-test plane depth and sorting groups from Rust

LibWeb: Resolve 3D sorting contexts on the Rust visual tree

LibGfx: Port the 3D plane BSP sorting to Rust

LibWeb: Compute the accumulated 2D scale of a visual context in Rust

LibWeb: Take the visual context tree's effective clip verdict from Rust

LibWeb: Carry url() effects filters to the visual context tree as bytes

LibWeb: Stop leaking visual context node types into unrelated headers

LibGfx: Add inverse, flatten and affine extraction to the Rust matrices

LibWeb: Make Rust the sole owner of hit-test display list structure

LibWeb: Rename hit testing 'box' fields to 'paintable'

LibWeb+Tests: Add an internals function to query the last context menu

LibWeb: Compute style record invalidation in Rust

LibWeb: Read transition and inheritance values from Rust records

LibWeb: Remove duplicate style reconstruction metadata

LibWeb: Keep style drive state in Rust

LibWeb: Handle animation inheritance from Rust records

LibWeb: Record complete style transaction inputs

LibWeb: Replace inherited style groups in Rust

LibWeb: Make computed longhand tables authoritative

LibWeb: Build computed style groups in Rust

LibWeb: Read computation inputs from Rust style records

LibWeb: Compute properties, animations, and transitions in Rust

LibWeb: Build custom property stores in Rust

LibWeb: Move longhand orchestration into Rust

LibWeb: Port SVG attribute parsing to Rust

LibWeb: Port the SVG path parser to Rust

LibWeb: Delete CSS parsing code orphaned by the Rust port

LibWeb: Validate CSS rules in Rust

LibWeb: Test CSS rule structural validation

LibWeb: Evaluate static if() conditions in Rust

LibWeb: Test if() condition callback boundaries

LibWeb: Finalize CSS declarations in Rust

LibWeb: Test devtools CSS declaration metadata

LibWeb: Parse sizes attributes in Rust

LibWeb: Test sizes attribute parsing

LibWeb: Serialize CSS supports env() features correctly

LibWeb: Evaluate CSS supports features in Rust

LibWeb: Test CSS supports feature evaluation

LibWeb: Parse page selector lists directly in Rust

LibWeb: Delete precomputed SVG path plumbing

LibWeb: Resolve CSS descriptor integers in Rust

LibWeb: Test calculated counter style descriptor integers

LibWeb: Evaluate static CSS supports features in Rust

LibWeb: Resolve CSS query feature names in Rust

LibWeb: Resolve CSS property names in Rust

LibWeb: Add CSS parser FFI counter baseline

LibWeb: Count remaining CSS parser FFI callbacks

LibWeb: Resolve custom property graphs in Rust

LibWeb: Keep post-compute adjustment in Rust

LibWeb: Apply style finalization in Rust

LibWeb: Store sampled animation values in Rust

LibWeb: Compute animation keyframe longhands in Rust

LibWeb: Compute initial document longhands in Rust

LibWeb: Batch monospace font-size recascade in Rust

LibWeb: Batch style computation preflight in Rust

LibWeb: Batch style finalization in Rust

CI: Do not update the Rust toolchain with dependabot

Meta: Update Rust toolchain to 1.98.0

LibWeb: Remove PaintableKind

LibWeb: Derive paint behavior from layout nodes

LibWeb: Remove paint tree dumping

LibWeb: Fold paint overflow into layout test dumps

LibWeb: Root the display list in an isolation frame instead of a layer

LibWeb: Carry a float rect and a clip mode in ClipData

LibWeb: Scope temporary recorder context switches in a helper

LibWeb: Rebuild the visual context tree when local clip inputs change

LibWeb: Drop the corner clip recorded around inner box shadows

LibWeb: Clip backdrop-filter to its own corner radii in the player

LibWeb: Add a clips_to_bounding_rect display list header flag

LibWeb: Give DisplayListPlayer an explicit frame interface

LibWeb: Read pointer-events from the element that was hit

LibWeb: Apply visual transforms to Range client rects

LibWeb: Pause adopted navigation bodies before population

LibRequests+UI/Qt: Keep request notifiers alive during callbacks

LibWeb: Ship display list command runs alongside the command bytes

LibWeb: Record display list command runs in the Rust builder

LibWeb: Remove the unused C++ DisplayList command builder

LibWeb: Derive sticky offsets from a Sticky spatial node

LibWeb: Remove the ScrollCompensation spatial node kind

LibWeb: Split the accumulated visual context into two trees

LibWeb: Hash layout tables with the style engine's fast hasher

LibWeb: Restore layout performance after modularization

LibWeb: Answer querySelector with one style-engine call

LibWeb: Share sibling positions across a selector query’s candidates

AK: Construct short Utf16FlyStrings directly in Rust

LibWeb: Tokenize HTML directly from UTF-16

LibWeb: Use Utf16FlyString names in the Rust HTML parser

LibWeb: Keep innerHTML input in UTF-16

LibWeb: Ensure all rust files are formatted

LibWeb: Paint CSS images through their observers' decoded image data

LibWeb: Keep layout node image observers addressable per style slot

LibWeb: Let decoded image data report a single-pixel color

LibWeb: Point image style value clients at their document resource

LibWeb: Remove the C++ layout tree mutation surface

LibWeb: Route every layout box removal through the arena

LibWeb: Build first-letter, marker and text wrapper subtrees from Rust

LibWeb: Place principal and pseudo-element boxes from the Rust builder

LibWeb: Perform table fixup and anonymous wrapper mutation in Rust

LibWeb: Move layout tree link ownership into the Rust arena

LibWeb: Narrow longhand drive C++ side effects

LibWeb: Construct retained cascade stores in Rust

LibWeb: Cache resolved fonts in the style engine

LibWeb: Give style transactions document length inputs

LibWeb: Publish resolvable inherited UI groups in Rust

LibWeb: Defer style record reclamation across updates

LibWeb: Merge reconstruction metadata in Rust

LibWeb: Skip counter environments for fixed list styles

LibWeb: Retain viewport dependencies in Rust

LibWeb: Avoid qualified names in style sharing keys

LibWeb: Avoid record views for style state probes

LibWeb: Query viewport-dependent styles in the engine

LibWeb: Order style reactions in the engine

LibWeb: Serialize CSS filters without url() in Rust

LibWeb: Move scrollbar and resizer geometry into Rust

LibWeb: Compute hit-test style facts in Rust

LibWeb: Commit SVG viewBox and percentage basis with fragments

LibGfx+LibWeb: Always trigger pending font loads

LibGfx+LibWeb: Use the first available font for metrics

LibWeb: Name the parsed prelude item payload

LibWeb: Share the CSS UTF-16 FFI marshaller

LibWeb: Reuse Rust CSS identifier checks

LibWeb: Share Rust CSS parse context construction

LibWeb: Export parsed CSS rule kinds from Rust

LibWeb: Speed up simple RGB color parsing

LibWeb: Delete the C++ canvas color parser

LibWeb: Add a Rust canvas color fast path

LibWeb: Delete the C++ CSS tokenizer prefilter

LibWeb: Filter CSS code points in the Rust tokenizer

LibWeb: Collect descriptors in Rust

LibWeb: Validate counter-style names in Rust

LibWeb: Validate @import preludes in Rust

LibWeb: Validate @function preludes in Rust

LibWeb: Validate @property rules in Rust

LibWeb: Pass syntax handles into Rust registries

LibWeb: Replace C++ syntax trees with Rust handles

LibWeb: Add shared ownership for Rust syntax trees

LibWeb: Parse query preludes in the syntax parser

LibWeb: Parse selector preludes in the syntax parser

LibWeb: Defer selector namespace validation

LibWeb: Share page selector prelude conversion

LibWeb: Name syntax prelude item kinds

LibWeb: Delegate numeric type algebra to Rust

LibWeb: Expose numeric type matching through Rust

LibWeb: Reuse the calculation numeric type in color resolution

LibWeb: Remove the keyword color fallback

LibWeb: Remove unused radial size resolution

LibWeb: Remove unused parser context checks

LibWeb: Use shared ABI types across the painting FFI

LibGfx: Make Matrix trivially copyable

LibWeb: Collect disconnected observers outside JS execution

LibWeb: Remove the unused size feature name table

LibWeb: Replace the Supports class with free functions

LibWeb: Emit media feature values as FFI PODs directly

LibWeb: Remove the C++ query expression tree

LibWeb: Evaluate container queries in Rust

LibWeb: Evaluate supports conditions in Rust

LibWeb: Evaluate media queries in Rust

LibWeb: Serialize container queries in Rust

LibWeb: Serialize supports conditions in Rust

LibWeb: Serialize media queries in Rust

LibWeb: Retain parsed query trees in Rust

LibWeb: Reject malformed env() references

Tests: Rebaseline for the Rust CSS parser

LibWeb: Delete the C++ CSS token model and syntax consumers

LibWeb: Remove CSS parser comparison gates

LibWeb: Delete the C++ substitution engine

LibWeb: Make Rust substitution resolution authoritative

LibWeb: Evaluate registered style queries natively

LibWeb: Track substitution cycles in Rust

LibWeb: Resolve custom functions in Rust

LibWeb: Resolve standalone substitution values in Rust

LibWeb: Traverse unresolved values in Rust

LibWeb: Highlight CSS from lean Rust tokens

LibWeb: Add a lean CSS syntax token FFI

LibWeb: Make Rust source value parsing authoritative

LibWeb: Retain unresolved values in Rust

LibWeb: Parse descriptors in Rust

LibWeb: Generate CSS descriptor metadata for Rust

LibWeb: Parse rule preludes in Rust

LibWeb: Delete the C++ query parser

LibWeb: Route all query parsing through Rust

LibWeb: Parse supports and container queries in Rust

LibWeb: Parse media queries in Rust

LibWeb: Add a Rust CSS query grammar

LibWeb: Cut fixed CSS value parsing overhead

LibWeb: Keep style-engine mutation helpers inlined

Tests: Update CSS parser unit tests for the Rust parser

Meta: Detect StyleBench completion instead of comparing counters

LibWeb: Parse substituted values on style workers

LibWeb: Resolve if() and custom functions in Rust

LibWeb: Resolve attr(), inherit() and env() substitution in Rust

LibWeb: Resolve registered custom property values in Rust

LibWeb: Share Rust CSS tokenizer source storage

LibWeb: Verify Rust syntax declarations against C++

LibWeb: Stop creating C++ tokens for stylesheet parsing

LibWeb: Build stylesheets and declaration blocks from Rust syntax trees

LibWeb: Consume CSS syntax in Rust

LibWeb: Remove the C++ CSS tokenizer

LibWeb: Remove the C++ CSS value parser

Meta: Add a CSS value parser microbenchmark

LibWeb: Reduce allocations in the Rust CSS value parser

LibWeb: Hand parsed component values to the Rust parser directly

LibWeb: Make the Rust CSS value parser the default

LibWeb: Parse substituted cascade values without a C++ round trip

LibWeb: Parse serialized CSS values in Rust

LibWeb: Parse CSS syntax definitions and typed values in Rust

LibWeb: Parse arbitrary substitution functions in Rust

LibWeb: Parse CSS shorthands in Rust

LibWeb: Make Rust longhand parsing authoritative

LibWeb: Parse remaining CSS longhands in Rust

LibWeb: Parse CSS counters, content, cursor and timelines in Rust

LibWeb: Parse CSS grid values in Rust

LibWeb: Parse CSS font values and descriptors in Rust

LibWeb: Parse CSS images and gradients in Rust

LibWeb: Parse CSS transforms, easing functions and filters in Rust

LibWeb: Parse CSS anchor positioning values in Rust

LibWeb: Parse CSS positions and basic shapes in Rust

LibWeb: Parse CSS colors in Rust

LibWeb: Parse CSS random() in Rust

LibWeb: Parse CSS calculations in Rust

LibWeb: Parse CSS strings, identifiers and URLs in Rust

LibWeb: Parse numeric CSS values in Rust

LibWeb: Parse CSS keywords and single-keyword display in Rust

LibWeb: Generate CSS property and keyword metadata for Rust

LibWeb: Add a Rust CSS value parser entry point with C++ fallback

LibWeb: Add shared Rust CSS component values and a token stream

LibWeb: Remove unused Layout::Node methods

LibWeb: Read paintable facts from layout nodes instead of snapshotting

LibWeb: Borrow paintable rows through arena views

LibWeb: Read box-model metrics through committed fragment links

LibWeb: House committed fragment links in the paintable arena

LibWeb: Retain the committed fragment link for every box

LibWeb: Retain SVG layout seeds as fragment links

LibWeb: Evict saved geometry with committed boxes

LibWeb: Read committed box metrics from fragments

LibJS: Transfer Rust string tables into executables

LibWeb: Transfer serialized UTF-16 string ownership

AK: Add native Rust UTF-16 string owners

LibWeb: Share UTF-16 fly string storage with Rust

AK: Add zero-churn UTF-16 ownership transfer

AK: Stabilize UTF-16 string storage layout

LibWeb: Tidy after the shell removal

LibWeb: Delete the C++ paintable shells

LibWeb: Let the Rust commit own paintable row lifecycle

LibWeb: Pass layout nodes through the paint host callbacks

LibWeb: Read committed rows by slot inside Painting

LibWeb: Tidy after the paint-state move

LibWeb: Keep SVG filter bounds in the arena side data

LibWeb: Track pending paint updates by arena slot

LibWeb: Route document paint state callers through paint_state()

LibWeb: Key the paint pipeline entry points by document

LibWeb: Move document paint state off the viewport paintable

LibWeb: Tidy the paintable header after the widget move

LibWeb: Drive chrome-widget eviction from arena row resets

LibWeb: Move chrome widgets into a slot-keyed document registry

LibWeb: Key chrome-widget geometry off layout nodes

LibWeb: Tidy the paintable header after the scroll move

LibWeb: Dispatch wheel scrolling without the paintable virtual

LibWeb: Move scroll mutation onto layout-node-keyed functions

LibWeb: Serve scroll reads from layout-node-keyed free functions

LibWeb: Move the scroll enums out of Paintable

LibWeb: Move caret paint helpers off the paintable subclasses

LibWeb: Route tool and repaint entry points through views

LibWeb: Key event handling by layout nodes instead of paintables

LibWeb: Serve SVG geometry queries from layout-node views

LibWeb: Key observer and style reads by layout nodes

LibWeb: Read CSSOM box geometry through layout-node views

LibWeb: Add layout-node-keyed views over paintable reads

LibWeb: Store arena slots in the retained hit-test items

LibWeb: Key caret positions by arena slot

LibWeb: Carry a DOM node and arena slot in hit-test results

LibWeb: Return caret owners as arena slots instead of shells

LibWeb: Delete BorderRadiiData and compute all border radii in Rust

LibWeb: Replace BordersData with a single border for outline queries

LibWeb: Delete DisplayListRecordingContext and C++ DevicePixelConverter

LibWeb: Remove dead FFI remnants of collapsed table border commit path

LibWeb: Retire the C++ paint-tree traversal API

LibWeb: Bubble wheel and key scrolling through layout containing blocks

LibWeb: Find scrollable ancestors through layout containing blocks

LibWeb: Walk layout containing blocks in intersection computation

LibWeb: Enumerate SVG paint children via the layout tree

LibWeb: Collect content-visibility boxes from the layout tree

LibWeb: Answer inline child-paintable presence from the arena

LibWeb: Fold repaint cache invalidation walks into the Rust arena

LibWeb: Clear all paint caches arena-wide on focus changes

LibWeb: Resolve event-dispatch DOM nodes in the Rust arena

LibWeb: Dump the paint tree from a flat Rust preorder export

Meta: Run Rust workspace tests in CI

LibWeb: Add missing Rust unit test FFI stubs

LibWeb: Stub C++ release callbacks in Rust unit tests

LibWeb: Fix Rust unit test compilation

LibWeb: Remove obsolete C++ selector support

LibWeb: Move selector ownership and serialization to Rust

LibWeb: Add the Rust selector parser core

LibWeb: Move the reused-subtree movement fixup into the Rust commit

LibWeb: Answer absolute-rect queries from the Rust arena memo

LibWeb: Commit box metrics through the Rust arena only

LibWeb: Never accumulate containing-block offsets for SVG paintables

LibWeb: Delete the C++ fragment and line mirror

LibWeb: Export visual lines as plain values and drop fragment pointers

LibWeb: Answer hit-test fragment questions from the arena records

LibWeb: Compute Range client rects from the Rust fragment records

LibWeb: Answer caret placement from the Rust fragment records

LibWeb: Build text render spans from the Rust fragment records

LibWeb: Apply the document selection to the arena in one aggregate call

LibWeb: Format the layout dump's fragment lines in Rust

LibWeb+LibGfx: Retain committed glyph runs in the Rust fragment records

LibWeb: Fast reject empty paint overlays

LibWeb: Cache unchanged descendant paint subtrees

LibWeb: Skip absent anchor callbacks during painting

LibWeb: Permit arena reads during hit testing

LibWeb: Store paint caches inline in the arena

LibWeb: Batch hit test item exports

LibWeb: Retain compatible paint caches across relayout

LibWeb: Invalidate absolute rect memos in constant time

LibWeb: Memoize base paint facts per recording

LibWeb: Fast reject caret-only box hit test facts

LibWeb: Use dense paint recording memo tables

LibWeb: Use retained paintable traversal facts

LibWeb: Fast reject flat 3D rendering context candidates

LibWeb: Remove dead NodeWithStyle methods

LibWeb: Recompute containing blocks inside the Rust arena

LibWeb: Move propagated text decoration cache invalidation to Rust

LibGfx: Compute GlyphRun bounds and intercepts with HarfBuzz, not Skia

LibWeb: Refill the Rust contained-boxes index in place

LibWeb: Retire the FFI surface orphaned by the overflow port

LibWeb: Move scrollable-overflow measurement into Rust

LibWeb: Derive reused-subtree movement from committed offset deltas

LibWeb: Mirror the scrollable-overflow contained-boxes index in Rust

LibWeb: Move physical overflow direction resolution into Rust

LibWeb: Share the axis-reverse predicates on the computed style view

LibWeb: Keep grid and flex layout data in Rust

LibWeb: Reset layout dirty flags inside the Rust arena

LibWeb: Limit client rect identity checks to ancestors

LibWeb: Skip no-op prefix state removal scans

LibWeb: Defer identity visual context rebuilds

LibWeb: Reduce visual context tree build overhead

LibWeb: Key paintable rows by their layout node's slot

LibWeb: Collapse the SVG paintable classes into kind dispatch

LibWeb: Collapse the stateless replaced-content paintables into kinds

LibWeb: Serve the committed SVG path from the paintable arena

LibWeb: Store SVG viewport geometry only in the paintable arena

LibWeb: Make the Rust paintable tree the only paintable tree

LibWeb: Derive paint-commit splice anchors from the layout tree

LibWeb: Resolve the image provider through ImagePaintable's layout node

LibWeb: Remove dead paintable FFI and virtuals left by the Rust port

LibWeb: Remove the superseded C++ painting implementation

LibWeb: Resolve gradients for painting in Rust

LibWeb: Record the display list and hit-test list in Rust

LibWeb: Record image paints in Rust

LibWeb: Port display list recording and hit testing to Rust

LibWeb: Use the Rust visual context tree and scroll state

LibWeb: Build the visual context tree and scroll state in Rust

LibWeb: Read paintable metrics, overflow and sticky state from the arena

LibWeb: Read paintable flags and selection from the arena

LibWeb: Serve grid and flex layout data from the Rust arena

LibWeb: Build a paintable tree in the Rust arena during layout commit

LibWeb: Compile the display list tape against the generated definitions

LibWeb: Define display list commands in Rust

LibWeb: Shape display list structs like their generated replacements

LibGfx: Expose font, path, and filter shims to Rust

LibGfx: Add Rust mirrors of the paint vocabulary types

LibWeb: Route stacking context dumps through a free function

LibWeb: Track stacking context tree validity with a viewport flag

LibWeb: Expose scrollbar paint color resolution as a query

LibWeb: Split text and caret paint resolution from recording

LibWeb: Write async scrolling metadata directly to the display list

LibWeb: Track SVG pattern references in the layout arena

LibWeb: Store indices instead of pointers in hit test items

LibWeb: Carry gradient interpolation as a Gfx type

LibWeb: Decouple SVG paint servers from display list recording

LibWeb: Rename display list tape fields to match the Rust writer

LibWeb: Avoid wrappers for simple mask values

LibWeb: Avoid allocating lists for first animation items

LibWeb: Avoid TLS when FFI counters are disabled

LibWeb: Avoid temporary wrappers for computed value lists

LibWeb: Compile replay support only into style-replay

LibWeb: Compute `border-spacing` to a two-value list

LibWeb: Compute legacy sRGB colors to one canonical `rgb()` form

LibWeb: Compute SVG stroke numbers to absolute lengths

LibWeb: Allow negative `stroke-dashoffset` values

LibWasm+WebContent+WebWorker: Route compilation through WasmCompiler

LibWebView: Manage the WebAssembly compiler as a singleton

WasmCompiler: Add an on-demand compiler service

LibWasmCompilerClient: Add a threaded compiler client

LibSandbox: Support forked helper processes

LibWasm: Use compact Cranelift compiler buffers

LibWasm: Back Cranelift batches with anonymous buffers

LibWasm: Stack compiled fault recovery contexts

LibCore: Add safe AnonymousBuffer snapshots

LibCore: Support sealable anonymous buffers

LibWeb: Check the Wasm disk cache after validation

LibWeb: Do not ignore the result of creating Wasm cache entries

LibWeb: Repair Rust style test fixtures

LibWeb: Filter Trusted Types attribute lookups

LibWeb: Skip impossible custom element definition lookups

LibWeb: Process ordinary parser text in runs

LibWeb: Reject non-custom element names early

LibWeb: Skip detached custom state invalidation

LibWeb: Avoid retaining unused parser stack attributes

LibWeb: Avoid unrelated attribute-name scans

LibWeb: Resolve image paints as data instead of recording them

LibWeb: Record nested display lists in a pre-pass before traversal

LibWebView: Add a lossless origin codec for snapshot storage

LibURL+LibIPC: Store a tuple origin's domain as a parsed host

LibWebView: Validate and install UI-process session-history snapshots

LibWebView: Drop StorageJar's hand-rolled UTF-16 conversions

LibDatabase: Bind borrowed bytes directly as a blob

LibDatabase: Bind and read optional values as SQL NULL

LibDatabase: Reject direct u64 bindings

LibWebView: Store history counters and sizes in SQLite's domain

LibDatabase: Add row-bounded statement execution and collection

LibDatabase: Add an exactly-one-row statement execution helper

LibHTTP: Make disk cache integer encoding explicit

LibDatabase: Bind and read UTF-16 text as WTF-8

LibDatabase: Add name-based parameter binding and ResultRow

AK: Make BitmapView searches respect the logical size

LibDatabase: Return ErrorOr from result callbacks

LibDatabase: Add storage-class-checked, bounded column reads

LibDatabase: Add a scoped transaction() helper

LibDatabase: Support enabling foreign keys via connection Options

LibDatabase: Read a column's length after its value, not before

Everywhere: Only write generated FFI files to Cargo's OUT_DIR

LibWeb: Generate all FFI headers with non-strict helper

LibWeb: Collapse the SVG layout box classes into Box

LibWeb: Map layout class names from the arena node kind

LibWeb: Rehome the remaining per-class layout behavior

LibWeb: Drive replaced-content sizing from the arena node kind

LibWeb: Create paintables from the arena node kind

LibWeb: Derive layout type predicates from the arena node kind

LibWeb: Reduce Rust style ownership overhead

LibWeb: Avoid StyleValue materialization during invalidation

LibWeb: Reduce Rust style transaction overhead

LibWeb: Batch style side effects and ownership releases

LibWeb: Remove remaining style computation callbacks

LibWeb: Remove the C++ longhand computation fallback

LibWeb: Resolve dynamic computed values in Rust

LibWeb: Resolve contextual calculations in Rust

LibWeb: Compute specialized longhands in Rust

LibWeb: Drive computed longhands through staged Rust entries

LibWeb: Return style transaction data without callbacks

LibWeb: Build computed value groups in Rust

LibWeb: Make StyleRecord the computed value object

LibWeb: Store computed style inputs in Rust

LibWeb: Move style value operations into Rust

LibWeb: Reuse committed paintable subtrees

LibWeb: Skip empty atomic block layout bodies

LibWeb: Add broad coverage for layout caching

LibWebView: Remove standalone history seeding

LibWebView: Restore entries through history loads

LibWebView: Match history loads by identity

LibWebView: Carry history with process-swap loads

LibWebView: Continue missing-target traversals in-place

LibWebView: Restore canceled navigations through operations

LibWebView: Reconstruct fallback traversals through operations

LibWebView: Recover crashed history through an operation

LibWebView: Continue requested traversals across process swaps

LibWeb+LibWebView: Make child history operations self-contained

LibWeb: Make changing history jobs entry-addressed

LibWeb+LibWebView: Traverse history from the UI on unhandled key events

LibWebView: Resolve browser traversal targets at their queue position

LibWebView: Start browser history traversals from the traversable

LibWeb: Restore DocumentState association on activation

LibWebView: Prevent history queue jump starvation

LibWeb: Add comprehensive layout tree update coverage

LibWeb: Resolve the relayout splice target inside the commit sink

LibWeb: Delete the read_paintable_geometry layout callback

LibWeb: Seed SVG-root partial relayout from saved committed geometry

LibWeb: Save committed SVG root geometry in an arena side table

LibWebView: Guess http for private-network addresses too

LibWebView: Guess http, not https, for loopback and localhost URLs

LibURL+LibWeb: Add and use Host::is_loopback_or_localhost()

LibWeb: Refresh anchor-name facts on retained layout nodes

LibWeb: Reject pseudo-elements in selector queries

LibWeb: Reject nested :host in :host() arguments

LibWeb: Preserve focus state while validating a new target

LibWeb: Keep decorated parents out of style sharing

LibWeb: Keep host compounds on the ordinary matching path

LibWeb: Republish directionality across slot dependencies

LibWeb: Read pending directionality facts

Compositor: Reject oversized shareable backing stores

LibWeb: Match :host alternatives inside selector-list pseudos

LibWeb: Preserve newer slot assignments during reassignment

LibWeb: Roll revert-layer back from the implicit outer layer

LibWeb: Republish auto direction after text control value changes

LibWeb: Re-resolve keyframe-borne inherit when the parent changes

LibWeb: Keep provisional transition values across animated updates

LibWeb: Survive focus moves from inside blur and focus handlers

LibWeb: Re-evaluate caret-color and accent-color on color changes

LibWeb: Do not keep typed custom property values past unregistration

LibWeb: Key custom property resolutions on the color scheme

LibWeb: Republish radio group validity when checkedness changes

LibWeb: Match :playing on the paused attribute alone

LibWeb: Re-enroll layout nodes for replaced-content facts on restyle

LibWeb: Keep animated values in layout-derived style records

LibWeb: Keep host compounds featureless when crossing the shadow root

LibWeb: Parse time strings without an ASCII-only detour

LibWeb: Stop tree-scoped name walks at detached shadow hosts

LibWeb: Charge retained prefix cache maintenance to residency

Documentation: Document the style engine

LibWeb: Switch style resolution to the new style engine

LibWeb: Add the style engine's record/replay and test suites

LibWeb: Add the style engine's flush and FFI boundary

LibWeb: Add the style engine's cascade and computed records

LibWeb: Add the style engine's matching and routing

LibWeb: Add the style engine's core data model

LibWeb: Add the style engine's selector IR and compiler

Meta: Add style measurement and profiling tools

AK: Add byte access, bulk copy, and equality to FixedBitmap

LibWeb: Emit SVG paths from shared fragment handles

LibWeb: Detect anchor-function insets with a node flag

LibWeb: Carry line data and owned layout payloads behind shared pointers

LibWeb: Carry fragments in links behind a shared pointer

LibJS: Keep GC cells in pointer wrappers

LibGC: Adapt weak pointers to sealed pointer wrappers

LibWeb: Remove NodeWithStyleAndBoxModelMetrics

LibWeb: Remove obsolete C++ available space types

CI: Recover from a partially installed Rust toolchain

CI: Select Xcode version 26.5

LibWeb: Read anchor() facts directly from Rust style values in layout

LibWeb: Drop the layout engine's `_mut` used-values accessors

LibWeb: Replace RetainedLayoutHandle with libgfx_rust OwnedPath

LibGfx: Add Rust OwnedPath wrapper for heap-allocated Gfx::Path

LibWeb: Rename rust_state to layout_state

LibWeb: Return the measured table box size on the wrapper's run result

LibWeb: Publish replaced content facts into the layout node arena

LibWebView: Do not trust the file position after truncating a download

Tests: Test downloading files

UI: Pause resumable downloads instead of canceling them on quit

UI: Add pause and resume buttons to the downloads popover

LibWebView: Show per-segment progress on about:downloads

LibWebView: Expose download pause and resume on about:downloads

LibWebView: Persist in-progress downloads across browser restarts

LibWebView: Add a store for in-progress downloads

LibWebView: Support pausing and resuming file downloads

LibWebView: Download files over multiple connections when possible

LibWebView: Add helpers for HTTP range planning

LibWebView: Track file downloads as a list of byte segments

LibWebView: Add a paused state to file downloads

LibWebView: Follow redirects when downloading a file

LibWeb: Remove per-element computed style overrides

LibWeb: Remove list item layout facts

LibWeb: Remove the FillEllipse display list command

LibWeb: Render list markers through generated content

LibWeb: Resolve relative positions during the Rust layout commit

LibWeb: Change read-only `DOMString` members to `USVString`

LibWeb: Declare the resolution types of `SubtleCrypto` promises

LibWeb: Use `undefined` rather than `void` in SVG interface IDL

LibWeb: Move the computed style accessor surface into the css module

LibWeb: Fold StyleReader into StyleValues

LibWeb: Drop the migration allowance from the computed value views

LibWeb: Carry grid track sizes as payload references, drop FfiSizeValue

LibWeb: Read gaps, SVG geometry and offsets through payload views

LibWeb: Model inset reads as a typed value instead of a decoded struct

LibWeb: Read margins and paddings straight from the surround payload

LibWeb: Read sizing properties straight from the style group payloads

LibWeb: Add lazy length-percentage views over computed style payloads

LibWeb: Store computed grid style as a Rust-native style group payload

LibWeb: Derive SVG element type facts from NodeKind

Meta: Separate Cargo builds from copied Rust outputs

LibWeb: Transfer saved abspos inputs within TreeBuilder

LibWeb: Use FfiDisplay directly for table roles

LibWeb: Hand layout a Rust-owned style container instead of a mirror

LibWeb: Mirror style group payloads into the layout node arena

LibWeb: Replace the layout size-value cache with an anchor-inset store

LibWeb: Read layout style scalars on demand from group payloads

LibWeb: Pin the layout style group indices at compile time

LibWeb: Move partial-rebuild bookkeeping from the C++ bridge into Rust

LibWeb: Trim arena-derivable fields from the descendant facts bundle

LibWeb: Compute replaced-display adjustment from the arena style mirror

LibWeb: Answer three tree-builder callbacks from the layout node arena

LibWeb: Remove dead has_auto_content_box_size virtual

LibWeb: Carry position-anchor in the surround twin, drop the residual

LibWeb: Move column width and count into the box twin

LibWeb: Move grid auto-flow to the box twin and delete the field schema

LibWeb: Move text-overflow, unicode-bidi and table-layout to box twin

LibWeb: Precompute layout font facts into a typed prefix twin

LibWeb: Read inherited text style through a typed prefix twin

LibWeb: Read border widths and styles through a typed prefix twin

LibWeb: Build anchor() inset calc wrappers in the Rust layout engine

LibWeb: Replace computed values only after the layout pass returns

LibJS: Select declarative Flap specializations

LibJS: Pass values to binary Flap slow paths

LibJS: Parse declarative Flap specializations

LibJS: Derive bytecodes from Flap handlers

LibJS: Snapshot generated Flap interpreter assembly

LibWeb: Move table grid formation fully into Rust

LibWeb: Move anonymous text run filtering to Rust

LibWeb: Read display from the box payload and drop the style snapshot

LibWeb: Convert the box style group to a Rust-native payload

LibWeb: Share the retained fly-string types across generated headers

LibWeb: Hoist computed aspect-ratio decoding into ComputedProperties

LibWeb: Move will-change into the misc reset style group

LibWeb: Delete the C++ ChunkIterator now that chunking lives in Rust

LibWeb: Chunk text in Rust and drop the text facts FFI callbacks

LibGfx+LibUnicode: Add font-cascade and segmenter shims for Rust layout

LibWeb: Move rendered text into a Rust-owned arena side table

LibWeb: Drop redundant fields from the text facts FFI snapshot

LibWeb: Drop the DOM ancestry callback from layout FC callbacks

LibWeb: Honor a zero `fit-content` argument when sizing a table

LibWeb: Compare tab advance against `0.5ch` without rounding first

LibWeb: Return slot ids instead of shells from layout FC callbacks

LibWeb: Remove the retired C++ layout engine

LibWeb: Switch layout execution to Rust

LibWeb: Add Rust layout bridge

LibWeb: Add Rust block formatting

LibWeb: Add Rust inline formatting

LibWeb: Add Rust inline line machinery

LibWeb: Add Rust SVG formatting

LibWeb: Add Rust grid formatting

LibWeb: Add Rust flex formatting

LibWeb: Add Rust table formatting

LibWeb: Add Rust formatting-context core

LibWeb: Add direct style access for Rust layout

LibWeb: Add Rust layout foundations

LibWeb: Add layout node facts

LibGfx: Add Rust wrappers for font and text layout

LibWeb: Remove redundant inline layout includes

LibWeb: Move table border arbitration into TableGrid

LibWeb: Export layout geometry seams

LibWeb: Move layout tree building into the shared libweb crate

LibWeb: Move style computation into the shared libweb crate

LibJS: Document Flap trusted-input boundaries

LibJS: Preserve names for every Flap source input

LibJS: Expose structured Flap diagnostics and reports

LibJS: Scope available loads to dominator subtrees

LibJS: Borrow immutable Flap checking context

LibJS: Report Flap parameter cleanup convergence accurately

LibJS: Cross-check Flap machine optimizations

Meta: Validate generated Flap interpreters in CI

LibJS: Price Flap layouts with the machine planner

LibJS: Add exact spill-free allocation fallback

LibJS: Share Flap machine register analysis

LibJS: Validate complete bytecode schemas

LibJS: Reject higher-order Flap inline recursion

LibJS: Split rematerializable Flap live ranges

LibJS: Intern Flap virtual registers once

LibJS: Make BytecodeDef parsing fallible

Meta: Add standalone Flap CI coverage

LibJS: Fix Flap Clippy violations

LibJS: Format Flap Rust sources

LibJS: Cache Flap machine-state dependencies

LibJS: Bound Flap inline expansion

LibJS: Forward Flap loads across linear block chains

LibJS: Express a check as a guard instruction with a side exit

LibJS: Fold a block into the only block that jumps to it

LibJS: Revisit an instruction's liveness only when a successor moves

LibJS: Point at an instruction's description instead of building it

LibJS: Let finalization take the graph's instructions

LibJS: Drop cold annotations in place when building a graph

LibJS: Group forwardable loads by the location they read

LibJS: Look up where an instruction sits instead of searching for it

LibJS: Hold live registers sparsely during allocation

LibJS: Collect block starts in a bitmap

LibJS: Rebuild successor lists once per graph cleanup

LibJS: Name an SSA value's register once, not once per use

LibJS: Build an effect set only when it moved

LibJS: Reuse Flap block labels across functions

LibJS: Stop counting unused Flap operand references

LibJS: Stop computing unused Flap loop analysis

LibJS: Invert a branch over a jump without moving the rest

LibJS: Number virtual registers as they first appear

LibJS: Ask only for the analyses a pass reads

LibJS: Find the instructions a branch absorbed in one walk

LibJS: Share a label's name and hash it once

LibJS: Hash the compiler's own tables cheaply

LibJS: Answer peephole liveness questions without rescanning

LibJS: Scope common-subexpression availability instead of copying it

LibJS: Hold effect dependencies in a sorted vector

LibJS: Compute Flap allocation successors without a graph

LibJS: Compact unreferenced Flap labels in place

LibJS: Streamline Flap control-flow graph cleanup

LibJS: Move instructions into Flap control-flow graphs

LibJS: Allocate registers over dense indices instead of names

LibJS: Reuse CFG edges during Flap optimization

LibJS: Index SSA value users before Flap lowering

LibJS: Drive constant propagation from a worklist

LibJS: Allocate unused AArch64 caller-saved registers

LibJS: Clear wide results of narrow Flap arithmetic

LibJS: Propagate constants through boxed Flap values

LibJS: Rematerialize constant Flap computations

LibJS: Conflict discarded results with live registers

LibJS: Recognize equivalent Flap memory locations

LibJS: Propagate effects in reverse postorder

LibJS: Find dominators without materializing dominator sets

LibJS: Avoid repeated graph scans in Flap

LibJS: Cache facts reused during Flap lowering

LibWeb: Read layout tree state from the Rust node arena

LibWeb: Add shared layout node storage for Rust

LibJS: Add the Flap low-level IR and machine backend

LibJS: Add Flap SSA construction and optimization

LibJS: Add the Flap high-level IR and semantic analysis

LibJS: Add the Flap front end

LibJS: Add the Flap compiler crate skeleton

LibWeb: Invalidate viewport-relative lengths nested in math functions

LibWeb: Move remaining computed style groups to Rust

LibWeb: Move computed style filtering and sizing to Rust

LibWeb: Keep longhand computation in Rust

LibWeb: Batch external calculation operations

LibWeb: Return animation and transition results directly from Rust

LibWeb: Remove obsolete C++ CSS helpers

LibWeb: Drive keyframe value preparation from Rust

LibWeb: Resolve animation property conflicts in Rust

LibWeb: Pass cascade and longhand values as Rust handles

LibWeb: Remove C++ animation value fallbacks

LibWeb: Complete per-element animation batching in Rust

LibWeb: Move complex animation interpolation to Rust

LibWeb: Evaluate keyframe intervals and transitions in Rust

LibWeb: Move remaining scalar and transform animation types to Rust

LibWeb: Retain complex style values in Rust

LibWeb: Retain miscellaneous compound style values in Rust

LibWeb: Move tagged and function animation values to Rust

LibWeb: Move compound geometry animation values to Rust

LibWeb: Establish batched Rust animation evaluation

LibWeb: Move transform interpolation to Rust

LibWeb: Retain transform and list children in Rust

LibWeb: Establish shared Rust style value handles

LibWeb: Keep text wrapper decisions in Rust

LibWeb: Keep first-letter matching in Rust

LibWeb: Keep assigned slot cleanup in Rust

LibWeb: Keep layout tree insertion in Rust

LibWeb: Keep layout tree postprocessing in Rust

LibWeb: Remove the C++ layout TreeBuilder class

LibWeb: Keep layout tree builder state in Rust

LibWeb: Keep layout tree recursion and context in Rust

LibWeb: Add a functional layout tree build API

LibWeb: Port specialized wrapper traversal to Rust

LibWeb: Hide internal layout tree builder helpers

LibWeb: Port layout tree cleanup decisions to Rust

LibWeb: Port specialized element box selection to Rust

LibWeb: Port pseudo-element construction to Rust

LibWeb: Port layout tree build orchestration to Rust

LibWeb: Move layout tree update orchestration to Rust

LibWeb: Port layout child hooks to Rust

LibWeb: Port principal descendant construction to Rust

LibWeb: Port principal box placement decisions to Rust

LibWeb: Port principal tree entry decisions to Rust

LibWeb: Port display-contents tree updates to Rust

LibWeb: Port specialized wrapper decisions to Rust

LibWeb: Port pseudo-element box decisions to Rust

LibWeb: Port layout child traversal to Rust

LibWeb: Move layout tree builder state to Rust

LibWeb: Port first-letter tree selection to Rust

LibWeb: Port layout tree insertion to Rust

LibWeb: Port table tree fixup to Rust

LibWeb: Start the Rust layout tree builder port

LibWeb: Split layout node creation phases out of TreeBuilder's walk

LibWeb: Resolve pseudo-element content once, after counters

LibWeb: Make TreeBuilder's rebuild confinement observable in tests

LibWeb: Extract self-contained helpers from TreeBuilder's walk

LibWeb: Give NodeWithStyle targeted setters for post-creation tweaks

LibWeb: Deduplicate child walks in TreeBuilder's two update paths

LibWeb: Move FfiDisplay into a shared Rust display module

LibWeb: Extract shared FFI plumbing from the Rust selector engine

LibWeb: Download hyperlinks with a `download` attribute

LibWebView+test-web: Refuse download requests in the test runner

LibWebView: Truncate temporary download filenames

LibWeb+LibWebView: Truncate suggested download filenames

LibWeb+LibWebView: Share the download filename sanitizer

LibWeb+LibWebView: Do not derive download filenames from data: URLs

LibWeb: Reapply adjustments for inherited animations

LibWeb: Adjust match-parent against animated parent styles

LibWeb: Preserve attr taint during variable substitution

LibWeb: Preserve custom property cycle invalidation

LibWeb: Flush post-compute adjustments from Rust

LibWeb: Decide input line-height clamping in Rust

LibWeb: Resolve effective color schemes in Rust

LibWeb: Adjust element styles in the Rust driver

LibWeb: Transform box types in the Rust driver

LibWeb: Compute text alignment in the Rust driver

LibWeb: Resolve effective overflow in the Rust driver

LibWeb: Return cascade value data with parsed shells

LibWeb: Mirror custom property registrations in Rust

LibWeb: Resolve custom property variables in Rust

LibWeb: Own unresolved token source text in Rust

LibWeb: Mirror custom property data in Rust

LibWeb: Cascade custom properties in Rust

LibWeb: Strengthen foreign type selector coverage

LibWeb: Match ID selectors case-insensitively in quirks mode

LibWeb: Match foreign type selectors case-sensitively

LibWeb: Remove the unused open-state parameter

LibWeb: Remove redundant selector DOM wrapper state

LibWeb: Remove the retired selector callback counter

LibWeb: Treat selector navigation as live DOM reads

LibWeb: Match remaining states through live DOM facts

LibWeb: Match media states through live DOM facts

LibWeb: Match common states through live DOM facts

LibWeb: Match language ranges in Rust

LibWeb: Match custom states through a live DOM query

LibWeb: Match direction through a live DOM fact

LibWeb: Match open popovers through live DOM facts

LibWeb: Match headings through a live DOM fact

LibWeb: Match fullscreen through a live DOM fact

LibWeb: Match focus states through live DOM facts

LibWeb: Match link states through live DOM facts

LibWeb: Match attributes through live DOM views

LibWeb: Match quirks classes through live DOM views

LibWeb: Match tag names through live DOM string views

LibWeb: Resolve selector namespaces through live accessors

LibWeb: Read selector element facts through live accessors

LibWeb: Compare selector element types through live wrappers

LibWeb: Read root selector state from the live DOM wrapper

LibWeb: Match common tag selectors through live DOM wrappers

LibWeb: Read selector identifiers through live DOM wrappers

LibWeb: Delete dead code hidden by allow(dead_code) in the style crate

LibWeb: Run the whole cascade as one bulk Rust operation per element

LibWeb: Build the background style group through the descriptors

LibWeb: Build the border style group through the descriptors

LibWeb: Build the surround style group through the descriptors

LibWeb: Build the box style group through the descriptors

LibWeb: Build the content and anchor style groups through descriptors

LibWeb: Build the inherited list style group through the descriptors

LibWeb: Build the inherited SVG style group through the descriptors

LibWeb: Build the SVG reset style group through the descriptors

LibWeb: Build the animation style group through the descriptors

LibWeb: Build the grid style group through the descriptors

LibWeb: Build the mask style group through the descriptors

LibWeb: Build the transform style group through the descriptors

LibWeb: Build the sizing style group through the descriptors

LibWeb: Build the inherited UI style group through the descriptors

LibWeb: Build the inherited text style group through the descriptors

LibWeb: Build the misc reset style group through the descriptors

LibWeb: Build the effects style group through the descriptors

LibWeb: Build the text reset style group through the descriptors

LibWeb: Build the alignment style group through the descriptors

LibWeb: Add descriptor-driven style group building to the core

LibWeb: Build the inherited table style group in Rust

LibWeb: Build the inherited box style group in Rust

LibWeb: Compute the font cluster natively and defer the rest to batches

LibWeb: Compute corner shapes and math-depth in the driver

LibWeb: Compute border widths and spacing longhands in the driver

LibWeb: Absolutize plain longhand values natively in the driver

LibWeb: Batch longhand stores that need no computation

LibWeb: Select longhand values natively in the Rust style core

LibWeb: Install a Rust-readable initial value table

Meta: Add style FFI baseline workloads

LibWeb: Count crossings of the style system's FFI boundary

LibWeb: Remove more code orphaned by the native Rust calc tree

LibWeb: Delete the C++ CalculationNode hierarchy

LibWeb: Build the Rust calculation tree natively everywhere else

LibWeb: Build the Rust calculation tree natively in typed-OM

LibWeb: Build the Rust calculation tree natively in the parser

LibWeb: Add a C++ builder over the Rust calc construction surface

LibWeb: Remove machinery orphaned by the Rust style and calc port

LibWeb: Compute remaining font longhands in the Rust core

LibWeb: Move property dependency predicates to the Rust core

LibWeb: Move position-area span-all remapping to the Rust core

LibWeb: Restore spec text comments lost in the Rust calc port

LibWeb: Resolve font property calc in the Rust compute core

LibWeb: Drop the stored C++ tree from calculated value data

LibWeb: Check anchor() containment over the Rust calc tree

LibWeb: Delete the C++ calc evaluation machinery

LibWeb: Route specified-time calc simplification through the Rust core

LibWeb: Fix four latent parity bugs in the Rust calc core

LibWeb: Delete the dead C++ calc serializer and resolve fallback

LibWeb: Absolutize calculated style values over the Rust calc tree

LibWeb: Fix round() strategy code order in the Rust calc core

LibWeb: Reify math expressions from the Rust calc tree

LibWeb: Evaluate and serialize random() through the Rust calc tree

LibWeb: Compare calculation trees structurally in Rust

LibWeb: Serialize calculations through the Rust calc tree

LibWeb: Resolve calculated values through the Rust calc tree

LibWeb: Simplify calculation trees in Rust

LibWeb: Run calculation operations over the Rust calc tree

LibWeb: Determine calculation types over the Rust calc tree

LibWeb: Port the numeric type algebra to the Rust calc module

LibWeb: Answer calc value predicates from the Rust tree

LibWeb: Build a Rust calculation tree alongside the C++ tree

LibWeb: Decide computational independence in the Rust value graph

LibWeb: Decide currentcolor dependence in the Rust value graph

LibWeb: Decide pseudo-element style bails in Rust

LibWeb: Time-travel the monospace font-size recascade in Rust

LibWeb: Read the cascaded store natively from the property driver

LibWeb: Run automatic box type transformations in Rust

LibWeb: Decide text-align adjustments in Rust

LibWeb: Resolve effective overflow values in Rust

LibWeb: Apply declaration lists to the cascade in Rust

LibWeb: Move the cascaded property store to Rust

LibWeb: Drive cascade origin ordering from Rust

LibWeb: Expand shorthands in Rust during declaration application

LibWeb: Orchestrate the longhand computation flow in Rust

LibWeb: Map logical property aliases in Rust

LibWeb: Drive the property computation loop from Rust

LibWeb: Compute border widths, corner shapes, and position-area in Rust

LibWeb: Compute font properties and line-height in Rust

LibWeb: Resolve lengths in Rust during style computation

LibWeb: Generate CSS property metadata tables for the Rust style core

LibWeb: Define inherited style group layouts in Rust

LibWeb: Hand ownership of style group payloads to Rust

LibWeb: Share style group payloads with the parent element

LibWeb: Add internals.styleGroupSharingInfo() for group introspection

LibWeb: Move reset values into shared style groups

LibWeb: Move inherited values into shared style groups

LibWeb: Add StyleStructRef, a copy-on-write style group reference

LibWeb: Add internals.computedValuesStats()

LibWeb: Move the CSS Rust code into its own crate under CSS/Rust

LibWeb: Skip inset reconstruction when no inset value is calculated

LibWeb: Intern small pixel lengths and common percentage values

LibWeb: Intern keyword, small integer and common number style values

LibWeb: Dispatch the color and iteration helpers by type tag

LibWeb: Dispatch absolutized by type tag

LibWeb: Dispatch equals by type tag

LibWeb: Dispatch serialize by type tag

LibWeb: Dispatch is_computationally_independent by type tag

LibWeb: Dispatch four style value operations by type tag

LibWeb: Materialize easing and basic shape data eagerly

LibWeb: Merge the color base data into the color variant payloads

LibWeb: Store border-radius and filter values in Rust-owned data

LibWeb: Hoist the Rust value handle into the StyleValue base class

LibWeb: Generate retained list impls in Rust with a macro

LibWeb: Share the style value pointer list marshalling helper

LibWeb: Update style value comments now that the conversion is done

LibWeb: Compare radial size components by value

LibWeb: Store image values in Rust-owned data

LibWeb: Store calculated values in Rust-owned data

LibWeb: Store basic shape values in Rust-owned data

LibWeb: Store grid track size lists in Rust-owned data

LibWeb: Store easing values in Rust-owned data

LibWeb: Store grid-template-areas values in Rust-owned data

LibWeb: Store conic and radial gradient values in Rust-owned data

LibWeb: Store linear gradient values in Rust-owned data

LibWeb: Store image-set values in Rust-owned data

LibWeb: Store color-mix values in Rust-owned data

LibWeb: Store color function values in Rust-owned data

LibWeb: Store the color style value base data in Rust

LibWeb: Store cursor values in Rust-owned data

LibWeb: Store counter style values in Rust-owned data

LibWeb: Store counter definitions and grid placements in Rust data

LibWeb: Store color-scheme and unresolved values in Rust-owned data

LibWeb: Store font source values in Rust-owned data

LibWeb: Store url() style values in Rust-owned data

LibWeb: Store radial size values in Rust-owned data

LibWeb: Store display values in Rust-owned data

LibWeb: Store tuple, transformation and shorthand values in Rust data

LibWeb: Store style value lists in Rust-owned data

LibWeb: Store four more style value types in Rust-owned data

LibWeb: Store position, shadow, content and counter values in Rust data

LibWeb: Store background, border-image and anchor values in Rust data

LibWeb: Store six more style value types in Rust-owned data

LibWeb: Store string and custom-ident values in Rust-owned data

LibWeb: Store ten more style value types in Rust-owned data

LibWeb: Store unicode-range, opacity and edge values in Rust-owned data

LibWeb: Store ratio style values in Rust-owned data

LibWeb: Store dimension style values in Rust-owned data

LibWeb: Store number and integer style values in Rust-owned data

LibWeb: Store KeywordStyleValue's data in a Rust-owned allocation

LibSandbox: Allow utimensat() in the filesystem write seccomp group

LibWeb: Add a Rust-owned style value data representation

LibUnicode: Gate Rust IDNA bindings behind a feature

LibWeb: Restore Rust :has() matching state with a guard

LibWeb: Tighten Rust selector FFI ownership

LibWeb: Document Rust selector matching

LibWeb: Generate the Rust selector matching FFI

LibWeb: Harden the Rust selector matching FFI

LibWeb: Compare interned strings in Rust selector matching callbacks

LibWeb: Cover An+B matching with step size 1 and a negative offset

LibWeb: Reject slots in ::slotted() before matching the argument

LibWeb: Characterize ::slotted() argument matching against slot elements

LibWeb: Count nth-child siblings under fragment roots

LibWeb: Widen Rust An+B matching arithmetic

LibWeb: Remove the C++ selector engine

LibWeb: Use the Rust selector matcher

LibWeb: Preserve :has() matching fast paths in Rust

LibWeb: Match borrowed DOM nodes through Rust

LibWeb: Port selector traversal to Rust

LibWeb: Compile selectors into a Rust representation

LibWeb: Add a Rust selector matching representation

LibWeb: Characterize selector matching behavior

LibWeb+WebContent+Compositor: Stream WebGL commands via shared memory

LibWeb: Split WebGL record layout and writing out of append_bytes

LibWeb: Collect partial relayout boundaries at dispatch time

LibWeb: Track partial relayout roots as generic layout boxes

LibWeb: Make formatting context factory functions static

LibWeb: Assign layout indices when layout nodes are constructed

LibWeb: Funnel post-layout-commit refreshes through one shared path

LibWeb: Propagate marks on already-dirty SVG partial relayout roots

LibWeb: Reinsert partial relayout roots at their paint tree position

LibWeb: Reassign scroll frames and text blocks after partial relayout

LibWeb: Don't use nested SVG roots as partial relayout boundaries

LibWeb: Simplify Rust HTML element insertion helper

Tests/LibWeb: Sync custom elements inner HTML tests with WPT

LibWeb: Store DOM names as UTF-16

LibWeb: Return CSS tokenizer payloads as UTF-16

LibWeb: Store XML namespace map values as UTF-16

LibWeb: Store web storage maps as UTF-16

LibWebView: Serialize history target names as UTF-8

LibWeb: Store CSS names as UTF-16

LibWeb: Avoid UTF-8 conversion for attr lookups

LibWeb: Store DOM and CSS identifiers as UTF-16

LibWeb: Store module specifiers and types as UTF-16

LibWeb: Use UTF-16 input values directly

LibWeb: Store WebCrypto algorithm names as UTF-16

LibWeb: Make explicit UTF-8 DOM attribute boundaries

LibWeb: Keep remaining HTML attribute paths as UTF-16

LibWeb: Parse CSS text from UTF-16 inputs

LibWeb: Serialize and reflect more attributes as UTF-16

LibWeb: Keep stylesheet and ARIA attributes as UTF-16

LibWeb: Take UTF-16 views in CSS parser helpers

LibWeb: Match element languages as UTF-16

LibWeb: Expose DOM node values as UTF-16

LibWeb: Store slot and part names as UTF-16 fly strings

LibWeb: Parse metadata attributes from UTF-16

LibWeb: Use UTF-16 SVG attribute values

LibWeb: Keep more HTML attribute consumers as UTF-16

LibWeb: Keep select item labels as UTF-16

LibWeb: Expose document colors as UTF-16

LibWeb: Format script src debug logs as UTF-16

LibWeb: Expose label htmlFor as UTF-16

LibWeb: Search CSP nonce attributes as UTF-16

LibWeb: Check supported image types as UTF-16

LibWeb: Parse legacy font sizes as UTF-16

LibWeb: Parse table alignment as UTF-16

LibWeb: Parse dimension values as UTF-16

LibWeb: Parse MathML scriptlevel as UTF-16

LibWeb: Keep DOM string-valued surfaces as UTF-16

LibWeb: Store DOMTokenList tokens as UTF-16

LibWeb: Expose reflected string attributes as UTF-16

LibWeb: Parse table border attributes as UTF-16

LibWeb: Parse input type attributes as UTF-16

LibWeb: Parse noopener link types as UTF-16

LibWeb: Match auto sizes as UTF-16

LibWeb: Parse link rel keywords as UTF-16

LibWeb: Translate preload destinations as UTF-16

LibWeb: Parse form attribute keywords as UTF-16

LibWeb: Use UTF-16 URL parsing overloads

LibWeb: Parse meta referrer content as UTF-16

LibWeb: Store TextTrack strings as UTF-16

LibWeb: Parse fetchpriority attributes as UTF-16

LibWeb: Parse referrer policy attributes as UTF-16

LibWeb: Parse table span attributes as UTF-16

LibWeb: Parse HTML numbers from Utf16View directly

LibWeb: Store CSS attr selector values as Utf16String

LibWeb: Store DOM attribute values as Utf16String

CI: Bump rust-toolchain from 1.96.0 to 1.96.1

CI: Warm up the pinned Rust toolchain in the setup action

LibJS: Ensure asmintgen works even when CARGO_TARGET_DIR is set

Meta: Accept $RUSTC_WRAPPER from env during configure

Meta: Stop compilers from spamming terminal during build

Libraries: Clean up UTF-16 source text paths

Libraries: Use UTF-16 for JS-visible runtime strings

Libraries: Parse JS strings from UTF-16

LibJS: Remove primitive string UTF-8 paths

LibJS: Store primitive strings as UTF-16

LibRegex: Compile ECMAScript patterns from UTF-16

LibJS: Use Utf16StringBuilder for JSON and Temporal strings

LibJS: Use Utf16StringBuilder for more strings

LibJS: Use Utf16StringBuilder for JS string construction

AK: Add Utf16StringBuilder formatting helpers

AK: Add Utf16StringBuilder

LibTextCodec: Use encoding_rs for legacy codecs

LibURL: Use encoding_rs for form URL encoding

Tests: Import some encoding related WPT tests

LibTextCodec: Make StreamingDecoder own decoder lookup

LibWeb/Infra: Add some missing AK includes

LibWeb: Avoid TextCodec when parsing JSON bytes

Test/LibTextCodec: Remove noisy test debug log

Tests/LibTextCodec: Do not refer to concrete encoders/decoders

LibTextCodec: Remove unused PDFDocEncoding

Meta: Bump curl to 8.20.0#2

Meta: Bump vcpkg baseline

LibJS: Remove unused C++ local variable wrapper

LibJS: Remove unused bytecode instruction stream iterator

LibJS: Move bytecode block counting to Rust

LibJS: Remove obsolete bytecode dump formatting helpers

LibJS: Move bytecode instruction dumping to Rust

LibJS: Remove unused C++ bytecode block classes

LibJS: Sync AsmInt program counter before slow paths

LibJS: Pass instruction pointers to AsmInt slow paths

LibJS: Remove AsmInt slow path stats collection

LibJS: Remove JS_BYTECODE_DEBUG

LibJS: Call AsmInt directly from run_executable

LibJS: Remove unused VM interpreter helpers

LibJS: Move final simple opcodes into AsmInt

LibJS: Split AsmInt slow paths out of Interpreter.cpp

LibJS: Move instruction bodies into AsmInt slow paths

LibJS: Remove AsmInt generic fallback dispatch

LibJS: Move property and call handlers into AsmInt

LibJS: Move control and binding handlers into AsmInt

LibJS: Move simple bytecode handlers into AsmInt

LibJS: Remove generic bytecode interpreter

LibWeb: Reduce CSS parser token memory usage

CI: Bump lint-code.yml to the 2026.06.02 image, like the rest of CI

LibWeb: Suppress false-positive LSan report during WebWorker teardown

CI: Fix recurring Rust toolchain flake in the libjs-test262 job

Meta: Remove fuzzers that primarily exercise third-party libraries

LibWeb+LibJS: Remove rust_pipeline_available

LibJS: Merge bytecode cache validation walks

LibJS: Avoid revalidating cached bytecode executables

Tests: De-flake abortsignal-timeout by dropping its wall-clock assertion

Meta: Rebuild Rust crates when the toolchain changes, not just sources

LibJS: Validate cached bytecode once before materializing

LibWeb: Route content blocker Rust allocations through mimalloc

Meta: Revert to a stable rust compiler

LibWeb/SecureContexts: Correct the 127.0.0.0/8 trustworthiness check

LibURL: Prefer Types.h typedefs over inttypes.h

LibURL: Replace WTF-8 surrogates before Rust URL parsing

CI: Avoid in-place nightly toolchain update in lint setup

LibURL: Optimize ASCII path/query parsing

LibURL: Remove C++ URL Parser implementation

LibURL: Expose rust host parsing over FFI

LibURL: Remove C++ URLPattern implementation

LibURL: Implement URLPattern in Rust

LibURL: Implement a URL parser in rust

LibUnicode/Rust: Expose IDNA to_ascii to Rust

CI: Use latest Linux build image

LibRegex: Hide the Unicode allocator override behind a feature

LibURL: Remove unused EncodeURI percent encode set

Rust: Set import granularity to Item

LibWeb: Normalize decoded HTML string parsing

LibWeb: Refresh blocker CSS after relevant class/id changes

LibWeb: Use adblock-rust in ContentBlocker

LibWeb: Add adblock-rust FFI hooks

LibWeb/Rust: Prepare build.rs for multi-config cbindgen generation

LibJS: Track shared function data ownership

LibJS: Preserve runtime caches across executable swaps

LibJS: Add executable backing state

LibJS: Reuse cached constant buffers when materializing

LibJS: Borrow bytecode cache tables when materializing

LibJS: Pre-size bytecode materialization tables

LibWeb: Populate platform mouse event data

LibJS: Pass var environment binding counts through FFI

LibJS: Use element alignment for bytecode array offsets

LibJS: Track var coordinates in var environments

LibJS: Keep cached bytecode file-backed

LibJS: Emit eager environment coordinates in bytecode

LibJS: Split dynamic environment lookups from coordinates

LibJS: Store bytecode cache indexes instead of pointers

LibRegex: Link libregex_rust before LibUnicode

LibWeb: Honor requested CSS tokenizer encoding

LibWeb: Use Rust preload scanner

LibWeb: Add Rust preload scanner

LibWeb: Treat fragment parser documents as disconnected

LibWeb: Keep deferred document.close cleanup on its parser

LibWeb: Remove the C++ HTML tree builder

LibWeb: Make the Rust HTML parser unconditional

LibWeb: Align declarative shadow root parsing

LibWeb: Complete Rust HTML tree construction

LibWeb: Wire Rust parser scripts and fragments

LibWeb: Add initial Rust HTML tree construction

LibWeb: Add Rust HTML parser host plumbing

LibWeb: Avoid unsafe tokenizer state conversion

LibWeb: Support dump tools without resource loading

Utilities: Add dump-html-tree

LibRegex: Allow lone surrogate escapes in /v mode character classes

LibJS: Return "" for empty legacy RegExp static properties

LibRegex: Reject duplicate named groups in nested alternatives

LibJS: Reject impossible bytecode cache table counts

LibJS: Borrow bytecode cache executable tables

LibJS: Borrow bytecode cache constant tables

LibJS: Align bytecode cache UTF-16 payloads

LibJS: Borrow bytecode cache UTF-16 strings

LibJS: Borrow mapped bytecode cache executable bytes

RequestServer: Send bytecode cache sidecars as files

LibRequests: Propagate body file mapping failures

LibHTTP: Report cache reader body sizes

RequestServer: Reuse disk-cache files after downloads

LibWeb: Preserve file-backed HTTP cache bodies

RequestServer: Send disk cache hits as file-backed bodies

LibCore: Add immutable byte storage for mapped ranges

LibWeb: Replace the HTML tokenizer with Rust

LibWeb: Add HTML tokenizer dump tests

LibJS: Fix var declarations in direct eval inside catch blocks

LibWasm: Store opcodes in 32 bits

LibWeb: Decouple ModuleScript from WebAssemblyModule

LibJS: Stop persisting basic_block_start_offsets on Executable

LibJS: Drop source ranges from bytecode source maps

LibJS: Deduplicate adjacent source map entries during codegen

LibJS: Materialize compiled function bytecode lazily

LibWeb: Invalidate async wheel state on listener changes

LibWeb: Allow viewport async scroll with nested scrollers

LibWeb: Reject async wheels over nested navigables

LibWeb: Add compositor debug logging

LibWebView: Route wheel bypasses over Compositor IPC

LibWeb: Scroll the viewport on the compositor thread

LibWeb: Add compositor scroll state snapshots

LibWeb: Present frames through Compositor IPC

LibWeb: Move RenderingThread into Compositor

Meta: Treat Rust warnings as errors

Meta: Extract common Rust compilation functionality to a helper

LibJS: Remove unused Rust function

LibJS: Remove unused rust_compile_program function

LibJS: Materialize decoded bytecode cache blobs

LibJS: Match bytecode cache blobs to their source

LibJS: Decode bytecode cache blobs over FFI

LibJS: Cache declaration function bytecode

LibJS: Return decoded bytecode cache blobs

LibJS: Decode bytecode cache executable records

LibJS: Persist bytecode cache declaration metadata

LibJS: Tag bytecode cache blobs with program type

LibJS: Validate bytecode cache blob records

LibJS: Serialize compiled bytecode cache blobs

LibJS: Split full off-thread script compilation

RequestServer: Expose cache sidecars over IPC

LibHTTP: Store associated data with disk cache entries

LibWeb: Compile remaining script functions in background

LibJS: Add off-thread function bytecode artifacts

LibJS: Move ScopeData into ScopeArena and reference it by ScopeId

LibJS: Intern identifier names in a per-arena string table

LibJS: Drop Cell<> wrappers from Identifier scope-analysis fields

LibJS: Move identifiers into a contiguous IdentifierArena

LibJS: Make CompiledRegex thread-safe with Arc + AtomicPtr

LibJS: Add AST arena types for identifiers, scopes, and interned strings

LibJS+LibWeb: Track Rust archive as input in static-lib merge

LibWeb: Stream Rust CSS tokenizer tokens over FFI

Tests: Add --silent mode to css-tokenizer utility

LibWeb/CSS: Avoid reconsume-then-consume dance in Rust tokenizer

LibWeb/CSS: Use a Rust enum for the internal Token type

LibWeb/CSS: Use Range for Rust Token ranged fields

LibWeb/CSS: Replace series of ifs in consume_a_token() with a match

LibWeb/CSS: Use tuples instead of U32Twin and U32Triplet

LibWeb/CSS: Rename next_code_point() to consume_code_point()

LibWeb/CSS: Port the CSS Tokenizer to Rust

LibWeb/CSS: Add missing spec comment to consume_string_token()

LibWeb/CSS: Stop using a define for the replacement character

LibJS: Range-check enum-typed bytecode fields in the validator

LibJS: Tighten the bytecode validator's argument operand bound

LibJS: Add negative tests for the bytecode validator

LibJS: Validate basic blocks, exception handlers, and source map

LibJS: Add per-field bytecode validation generated from Bytecode.def

LibJS: Add bytecode validator scaffolding driven from Bytecode.def

Devcontainer: Install rust via devcontainer feature

LibGfx: Add the mimalloc allocator shim to liblagom-gfx.so

LibJS: Build functions_to_initialize in source order

LibJS: Use natural source positions for parser-synthesized identifiers

LibJS: Replace in_property_key_context flag with explicit consume helper

LibJS: Precompile top-level IIFEs off-thread

LibWeb+LibJS: Compile fetched top-level JS off-thread

LibJS: Resolve VM constants during executable creation

LibJS: Defer function data materialization

LibJS: Track nested function ids during Rust parsing

LibJS: Preserve source positions in bytecode source maps

LibWebView: Add bookmark import/export to about:bookmarks

LibJS: Make bytecode register allocator O(1)

LibJS+LibUnicode: Use LibUnicode as appropriate for lexing JavaScript

LibRegex+LibUnicode: Migrate Unicode Rust FFI methods to LibUnicode

LibUnicode: Hide the Unicode allocator override behind a feature


-- Total Rust changes: 418737 insertions, 93246 deletions

-- Total Non-Rust Code changes: 148662 insertions, 224476 deletions

-- Total Non-code changes: 147779 insertions, 85347 deletions

-- Total New Rust ratio: 235.44334013280675%


Lines of Code

-- Rust Adoption Rate: 41.160676145725276%


More Rust than Churn? YES (Churn: code[75814] + non-rust[62432] = 138246, Rust: 325491)