Is Ladybird Rust Yet?

Is Rust Profitable Yet?
Last updated on 04:00PM on July 29, 2026 (TZ: UTC+0000)

Individual commit stats

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: 153543 insertions, 23470 deletions

-- Total Non-Rust Code changes: 62411 insertions, 87904 deletions

-- Total Non-code changes: 13108 insertions, 7131 deletions

-- Total New Rust ratio: 413.3238004448681%


Lines of Code

-- Rust Adoption Rate: 23.175929730442128%


More Rust than Churn? YES (Churn: code[25493] + non-rust[5977] = 31470, Rust: 130073)