Is Ladybird Rust Yet?

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

Individual commit stats

AK: Adopt mimalloc v2 as main allocator

Meta: Remove ENABLE_RUST build configuration option

LibJS: Handle empty UTF-16 strings in Rust FFI

LibJS: Retry Unicode low-surrogate lastIndex positions

LibRegex: Preserve negated class direction in lookbehind

LibRegex: Leave suffix minima for repeated simple loops

LibRegex: Honor wrapped start anchors in search hints

LibRegex: Clamp braced quantifier bounds to 2^31 - 1

LibRegex: Compare set operands by exact string length

LibJS: Reject mixed surrogate forms in RegExp names

Meta: Make Rust FFI headers reproducible

LibWeb: Remove spin_until from check_if_unloading_is_canceled()

LibRegex: Reject bare ranges in /v set operations

LibRegex: Respect V8 astral literal lastIndex behavior

LibRegex: Keep empty-match surrogate candidates

LibRegex: Fix backward greedy lookbehind backtracking

LibRegex: Fix greedy \w and \W ignore-case handling

LibJS: Fix RegExp.prototype.test ignoring overridden prototype exec

LibRegex: Restore broad ECMA-262 test coverage

LibRegex: Fail fast when matches need a missing literal

LibRegex: Collapse simple `a|a?`-style disjunctions

LibRegex: Fix greedy lookbehind backtracking boundaries

LibRegex: Preserve captures when loops reject empty matches

LibRegex: Remove stale GreedyLoop snapshot comment

LibRegex: Restore capture state during loop backtracking

LibRegex: Avoid widening ASCII regex input

LibJS: Validate regex literals during parsing

LibRegex: Remove the legacy C++ ECMA-262 engine

LibJS+LibRegex: Switch RegExp over to the Rust engine

LibRegex: Add ECMAScriptRegex and migrate callers

LibRegex/Rust: Add the ECMA-262 regex engine

Tests: Import V8 and WebKit regexp suites

AK: Guard JSON parser against deep nesting

LibWeb/HTML: Make more events trusted

LibWeb/HTML: Make form submit event trusted

LibJS: Remove C++ pipeline compatibility hacks from Rust codegen

LibJS: Improve bytecode executable dump format

LibJS: Add more early errors in Rust parser

LibJS: Reject arguments/eval in strict mode destructuring and arrows

LibJS: Reject new.target in arrow functions at global scope

LibJS: Add missing early errors in Rust parser

test262-runner: Remove parse-only fast path for negative tests

LibJS: Replace ScopedOperand with Operand in bytecode ops

LibJS: Remove remaining C++ pipeline artifacts

LibJS: Remove C++ lexer, use Rust tokenizer for syntax highlighting

LibJS: Remove C++ AST

LibJS: Remove C++ parser

LibJS: Remove C++ AST constructor from SharedFunctionInstanceData

LibJS: Remove C++ bytecode codegen

LibJS: Remove dead C++ bytecode compilation functions

LibJS+LibWeb: Port remaining callers to Rust pipeline

LibJS: Remove LIBJS_CPP env var and ENABLE_RUST guards

LibJS: Remove C++ compiler pipeline fallback paths

LibJS: Remove pipeline comparison infrastructure

LibJS: Use enum for retrieving well known symbols from C++ to Rust

LibJS: Directly use LiteralValueKind enum across FFI boundary

LibJS: Route canParseSource through Script::parse and add parser modes

LibJS: Align new-expression paren flags with C++ parser

LibJS: Keep new call-paren optional chaining valid

LibJS: Reject optional chaining on unparenthesized new

LibJS: Isolate super validity in nested function scopes

LibJS: Reject invalid bare private identifier usage

LibJS: Fix async arrow and for-of async parsing

LibJS: Align duplicate parameter early errors

LibJS: Enforce const initializers in declarations

LibUnicode: Apply workspace clippy lints to Rust code

LibUnicode: Generate FFI bindings with cbindgen

LibJS: Generate FFI header using cbindgen instead of hand-rolling

CMake: Pass cargo a path for dumping generated headers from build.rs

LibJS: Wrap ParseErrorCallback typedef in Option

Meta: Add lints to Rust workspace lint configuration

LibJS/Rust: Apply lint clippy::explicit_iter_loop

LibJS/Rust: Apply lint clippy::borrow_as_ptr

LibJS/Rust: Apply lint clippy::unnested_or_patterns

LibJS/Rust: Apply lint clippy::redundant_clone

LibJS/Rust: Apply lint clippy::elidable_lifetime_names

LibJS/Rust: Apply lint clippy::ref_option

LibJS/Rust: Apply lint clippy::useless_let_if_seq

LibJS/Rust: Apply lint clippy::unnecessary_wraps

LibJS/Rust: Apply lint clippy::manual_let_else

LibJS/Rust: Apply lint clippy::semicolon_if_nothing_returned

LibJS/Rust: Apply lint clippy::uninlined_format_args

Documentation: Clarify Rust installation note

LibJS: Fix AssignmentTargetType for NewExpression and strict mode

Meta: Replace corrosion with custom function that tracks dependencies

LibJS: Use the 2024 Rust edition for AsmIntGen and ByteCodeDef

Meta: Remove `git diff` check from cargo linters

LibJS: Add Mov2/Mov3 instructions to reduce dispatch overhead

LibJS+LibUnicode: Use icu4x for Temporal calendar operations

LibWeb: Floor coordinates for untrusted MouseEvent and PointerEvent

LibWeb: Initialize pageX/pageY and offsetX/offsetY in event constructors

LibJS: Store cache pointers directly in bytecode instructions

LibJS: Replace GC::Weak with GC::RawPtr in inline cache entries

AsmInt: Remove redundant accessor check from GetByValue

AsmInt: Inline environment binding path for GetGlobal/SetGlobal

LibJS: Add AsmIntGen assembly interpreter code generator

LibJS: Extract BytecodeDef into a shared Rust crate

LibJS: Move Interpreter::get/set inline and expose internals

LibJS: Convert Object bitfields to a flags byte

LibJS+LibWeb: Parse modules off the main thread

LibJS+LibWeb: Add C++ compile_parsed_module wrapper

LibJS: Add rust_compile_parsed_module() for pre-parsed modules

LibJS+LibWeb: Parse classic scripts off the main thread

LibJS: Add C++ parse_program/compile_parsed_script wrappers

LibJS: Split rust_compile_script() into parse and compile steps

LibJS: Add tests for regex literal parse-time error reporting

LibJS: Defer regex literal compilation to post-parse step

LibThreading: Add ThreadPool class

LibThreading: Allow configuring thread stack size

LibJS: Emit ThrowIfTDZ before simple assignment to let variables

LibJS: Inline JS-to-JS calls in the bytecode interpreter dispatch loop

LibJS+LibWeb: Use InterpreterStack for all execution context allocation

LibJS: Add InterpreterStack bump allocator for execution contexts

LibJS: Consolidate Put bytecode instructions and reduce code bloat

LibJS: Add UsingDeclaration to needs_block_declaration_instantiation

LibJS: Fix ResolveThisBinding/ResolveSuperBase emission order

LibJS: Keep arg_holders alive in generate_arguments_array

LibJS: Fix register order in private logical assignment

LibJS: Optimize constant string computed properties to MemberId

LibJS: Clear pending_lhs_name for named class expressions

LibJS: Only set pending_lhs_name for non-empty class field names

LibJS: Remove redundant ThrowIfTDZ from Rust emit_set_variable

Meta: Add a rust-toolchain toml file to pin required rust version

LibJS/Rust: Create for-of loop blocks before evaluating iterable

Tests/LibJS: Add bytecode test for for-of with conditional in RHS

LibJS/Rust: Skip TDZ check for self-move in emit_set_variable

Tests/LibJS: Add test for compound assignment after destructuring

LibJS/Rust: Don't pass preferred_dst for destructuring assignment RHS

Tests/LibJS: Add bytecode test for destructuring assignment in &&

LibJS/Rust: Push LeaveLexicalEnvironment boundary in for-of loops

Tests/LibJS: Add bytecode test for for-of continue with block scope

LibJS/Rust: Push LeaveLexicalEnvironment boundary in switch statements

Tests/LibJS: Add bytecode test for return from switch with block scope

LibJS/Rust: Handle private member update expressions

Tests/LibJS: Add bytecode test for postfix increment on private member

LibJS/Rust: Call perform_needed_unwinds before Throw instructions

Tests/LibJS: Add bytecode test for async await in try-catch with scope

LibJS/Rust: Use correct capacity for CreateVariableEnvironment

Tests/LibJS: Add bytecode test for var environment capacity

LibJS/Rust: Always allocate fresh register for postfix update result

Tests/LibJS: Add bytecode test for postfix update in logical AND

LibJS/Rust: Restore unwind handler when trampolining through finally

Tests/LibJS: Add bytecode test for nested try-finally continue

LibJS/Rust: Fix several bytecode mismatches with the C++ pipeline

LibJS/Rust: Use GetLengthWithThis for super.length property access

LibJS/Rust: Fix evaluation order for super in tagged templates

LibJS/Rust: Fix evaluation order in delete super[key]

LibJS/Rust: Don't emit dead code after Throw for invalid LHS

LibJS: Don't emit dead code after Throw for invalid LHS expressions

LibJS: Skip AST dump for ClassFieldInitializerStatement

LibJS/Rust: Fix has_parameter_expressions and TDZ checks for arguments

LibJS: Compare Rust and C++ bytecode for lazily compiled functions

LibJS/Rust: Add aggressive optimisations for distribution

LibJS: Cache ASCII-to-UTF-16 source conversion for Rust compilation

LibJS: Defer GC during Rust-pipeline module and builtin compilation

LibJS: Memoize failed arrow function attempts in Rust parser

Meta: Add 'cargo clippy -- -D clippy::all' to lint-ci.sh

LibJs/Rust: Migrate to edition 2024

Meta: Add 'present' to check style copyright regex and skip .rs files

CI: Add 'cargo fmt --check' and setup rust toolchain to lint-ci

LibJS/Rust: Cargo fmt on all source files

LibJS/Rust: Clean build script up

LibJS: Include AST.h in RustIntegration.h

Flatpak: Add Rust toolchain and vendored cargo dependencies

CI: Install Rust toolchain in setup action

LibJS: Add alternative source-to-bytecode pipeline in Rust

LibJS: Suppress global identifier optimization for dynamic functions

LibJS: Restore ancestor scope flags after failed arrow parsing

LibJS: Register using declarations in scope collector for for-loops

LibJS: Defer scope registration of object property identifiers

Tests/LibJS: Import various tests developed alongside Rust pipeline

LibJS: Always consume exponent in decimal numeric literals

LibJS: Add dump_to_string() for AST nodes and bytecode executables

LibJS: Ensure deterministic ordering in scope analysis and codegen

Meta: Add Corrosion as a CMake dependency for Rust integration

Meta: Add Rust toolchain as a build dependency


-- Total Rust changes: 49342 insertions, 7655 deletions

-- Total Non-Rust Code changes: 8855 insertions, 37179 deletions

-- Total Non-code changes: 34673 insertions, 7753 deletions

-- Total New Rust ratio: 75.45977843747738%


Lines of Code

-- Rust Adoption Rate: 8.014225401349934%


More Rust than Churn? NO (Churn: code[28324] + non-rust[26920] = 55244, Rust: 41687)