Is Ladybird Rust Yet?

Is Rust Profitable Yet?
Last updated on 08:00AM on June 09, 2026 (TZ: UTC+0000)

Individual commit stats

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: 32854 insertions, 5671 deletions

-- Total Non-Rust Code changes: 10824 insertions, 17276 deletions

-- Total Non-code changes: 6940 insertions, 5143 deletions

-- Total New Rust ratio: 329.5308522245121%


Lines of Code

-- Rust Adoption Rate: 12.522357812245936%


More Rust than Churn? YES (Churn: code[6452] + non-rust[1797] = 8249, Rust: 27183)