Is Ladybird Rust Yet?

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

Individual commit stats

test-web: Load tests from an origin that is not potentially trustworthy

RequestServer+LibWebView: Resolve .test names to loopback in test mode

LibDNS: Let a resolver resolve names within chosen domains to loopback

LibWeb: Make fetch Request reference-counted instead of GC-allocated

LibTextCodec: Include the StringView that an Encoder holds

LibWeb: Move a fetch request's body stream to the JS Request

LibWeb: Hold a fetch request's prompt traversable by id

LibWeb: Name a fetch request's client by its address

LibWeb: Give environment settings objects an address

LibWeb: Resolve a blob request's URL entry at fetch start

LibWeb: Read a fetch's client through its snapshot

LibWeb: Introduce fetch client context snapshots

LibWeb: Account for in-flight keepalive bytes per fetch group

Tests: Read an echo request's body before responding

LibWeb: Keep the top-level origin of serialized environment settings

LibWeb+WebWorker: Serialize a stand-in with the global it was taken from

LibWeb: Report no violations for a stand-in of a remote environment

LibWebView: Persist a history entry's insecure requests policy

LibWeb: Keep the insecure requests policy on the policy container

LibWebCommon: Refuse an unknown insecure requests policy over IPC

LibWeb: Round integer animation ties toward positive infinity

LibWeb: Import WPT coverage for integer interpolation rounding

LibWeb: Expose Touch Events and dispatch touch contact lists

LibWeb: Import Touch and TouchEvent constructor coverage

LibWeb: Dispatch WebDriver touch and pen pointer actions

LibWeb: Preserve pointer input data and isolate pointer state

LibWeb: Import pointer coordinate and touch handler exposure tests

LibWeb: Cover pointer input properties and independent capture

AK: Match Rust panic callback parameter types to the FFI

LibWeb: Cover mouse pointer move and boundary event defaults

CI: Fail the macOS AX preflight on a screen-locked session

CI: Cache Rust compiles with sccache, as ccache caches C++ compiles

LibJS: Build the standalone runtime independently of LibWeb

LibWeb: Throw a TypeError for a missing WebAssembly table value

LibWeb: Keep one copy of a WebAssembly module's bytes

LibWeb: Throw a RangeError when a WebAssembly memory allocation fails

LibWeb: Reject v128 and exnref types before a WebAssembly call

LibWeb: Hold a WebAssembly Memory's buffer objects strongly

LibWasm: Remove the C ABI that only LibWeb used

LibWeb: Implement the WebAssembly JS API in Rust

LibWeb: Support namespaces and more IDL in the Rust bindings

LibJS: Expose host classes, modules and errors to Rust embedders

LibWasm: Build the engine's C ABI only for LibWasm

LibWeb: Implement the HTML Sanitizer API

LibWeb: Set the script text of scripts parsed in the fragment case

LibWeb: Only remove the body for a frameset tag if it has a parent

Tests/LibWeb: Import Sanitizer API WPT tests

LibJS+LibWasm: Keep JIT compilation available on x86-64-v2 CPUs

CI: Add a workflow that packages Distribution builds

Meta+UI: Give release builds a version

Meta+UI: Package the browser and its symbols with CPack

Meta: Configure CPack once for the whole project

Tests/LibMedia: Build TestSystemFFmpeg only with a shared libavcodec

Tests/LibGfx: Build TestRustCrateCopies only for shared libraries

AK+LibCore: Keep caught Rust panics out of crash reports

Meta+CI: Run the Rust GC lints in lint-ci.sh

Meta+LibJS: Reject GcRefCells around state the collector never reads

Meta: Reject untraced types that keep GC pointers in heap memory

Meta: Reject GC pointer dereferences in the Drop of what cells own

Meta+LibJS: Reject untraced fields that can hold GC pointers

Meta+LibJS: Add a rustc driver with lints for libjs_rust's GC

LibJS: Keep keys that are never symbols in a NonSymbolPropertyKey

LibJS: Build or trace the rest of what keeps cells in heap memory

LibJS+LibWeb: Keep what holds cells in heap memory within a deferral

LibJS+LibWeb: Build cells under a deferral of collections

LibJS+LibWeb: Defer collections while traced state is borrowed

LibGC+LibJS: Defer collections from Rust without a call into LibGC

LibJS: Keep state the collector never reads out of GcRefCell

LibJS: Tie what the JIT keeps cells in to the deferral that keeps them

LibJS: Say that a GcWeak holds no Gc

LibJS: Create disposable stacks with a new dispose capability

LibJS: Ask whether a cell died only of the sweep in progress

LibJS: Give weak containers no VM while they remove dead cells

LibJS: Lend the execution contexts of a paused stack trace

LibJS: Keep Values on the thread of their VM

LibJS+LibWeb: Make the bits of a Value private to libjs_rust

LibJS: Implement Trace for what owners traced field by field

LibJS: Keep arguments of JIT calls that do not fit inline in one list

LibJS: Keep the remaining temporary lists of cells in MarkedVecs

LibWeb: Return sequences of cells from Rust bindings in MarkedVecs

LibWeb: Build Rust bindings' arrays and rect lists from rooted lists

LibJS: Root the arguments of a RegExp replacer function

LibJS: Root the functions of stack traces

LibJS: Lend the attached debugger instead of sharing it

LibJS: Keep collections deferred while JIT code is installed

LibJS: Pass a DeferGc to the JIT code that relies on its caller's

LibJS: Have a bytecode cache install borrow the functions it matches

LibJS: Build executables while collections are deferred

LibJS: Root the strings that jit.exitSites creates

LibJS+LibWeb: Lend a MarkedVec's values instead of copying them out

LibJS+LibWeb: Trace lists of values only through GcRefCells

LibJS: Move DeferGc to the heap

LibJS: Remove the unused Executable::new

LibGfx: Remove the Gfx::Path queries that only LibWeb asked

LibWeb: Measure SVG geometry in Rust instead of through Gfx::Path

LibWeb: Paint a focused area's focus ring from the shape Rust built

LibWeb: Don't treat NavigateEvents created by script as trusted

LibWeb: Clear the target element when the fragment does not exist

LibWeb: Restore scroll positions after intercepted traversals

Tests/LibWeb: Import navigation API tests

Meta+UI: Write separate symbol files for Distribution builds

UI: Strip the main executable of installed macOS bundles

LibWeb: Make the C++ views of a declaration block on first use

LibWeb: Drop the custom property references memo of declaration data

LibWeb: Keep whole-number RGB colors in rgb() form when interning

LibWeb: Share the numbers of parsed colors

LibWeb: Drop the growth slack of parsed declaration blocks

LibWeb: Make inline style views only for blocks that hold images

LibWeb: Stretch MathML operators and draw large operators

LibWeb: Paint MathML fraction bars and radical symbols

LibWeb: Use the MATH table constants in MathML layout

LibGfx: Read the OpenType MATH table through HarfBuzz

Tests/LibWeb: Import WPT tests for stretchy MathML operators

LibWeb: Inline the layout style and node lookup accessors

LibWeb: Look up a style transaction's records from the last one found

LibWeb: Skip settling pseudo-elements an element cannot generate

LibWeb: Skip unstyled subtrees when looking for generated content state

LibWeb: Charge later style pass waves to their own phase clocks

LibWeb: Ask about an element's animations only where it is asserted

LibWeb: Keep shadow hosts' pseudo-element matches across transactions

LibWeb: Keep anchor names in tree order across moveBefore()

LibWeb: Test anchor and animation names across restyles and moves

LibWeb: Rebuild the inherited UI group when the color moves

LibWeb: Mark popstate and hashchange events as trusted

LibWeb: Rate limit history updates and traversals

Tests/LibWeb: Import WPT tests for history API rate limits

LibWeb: Implement Event Timing

LibWeb: Implement Paint Timing

Tests/LibWeb: Execute pointer actions in testdriver-vendor.js

LibWeb: Check the current URL of mixed content requests

LibWeb: Implement the upgrade-insecure-requests directive

Tests/LibWeb: Add tests for upgrade-insecure-requests

LibWeb+LibWebView+WebContent+WebWorker: Report worker CSP violations

Tests/LibWeb: Import CSP tests for blocked worker script requests

LibWeb: Decide the relayout of the host's style install in Rust

LibWeb: Drop the conservative style reset of animated SVG boxes

LibWeb: Share the layout-input style comparison with Rust

LibWeb+LibWebView: Give popups their creator's top-level creation URL

LibWeb+LibWebView: Make top-level data: documents non-secure contexts

LibWeb: Count AudioBuffer sample storage toward GC pressure

LibWeb: Taint canvases with video from CORS-cross-origin responses

AK+Meta: Remove debug macros whose code moved to Rust

Meta: Remove the CSS value grammar parser

test-web: Stop setting verification variables that nothing reads

LibGfx: Remove the C++ table of supported font technologies

LibWeb: Remove HTMLToken members that the Rust parser made unused

LibCompositing: Stop asking cbindgen for canvas types that are gone

LibGfx: Remove paint enum decoders that nothing calls

LibWeb: Move the newline line helpers into VisualLines

LibWeb: Arm render clock contexts with their ticks, not a callback

LibWeb: Remove leftovers of the C++ cascade in the style computer

LibWeb: Remove CSS helpers that the Rust style and layout replaced

LibWeb: Remove StyleValue accessors that nothing reads

LibWeb: Remove more StyleValue subclasses nothing reads

LibWeb: Remove the dependencies of declaration blocks

LibWeb: Remove the qualified layer names of CSS rules

LibWeb: Remove ComputedValues accessors that nothing reads

LibGfx: Remove IPC coding of transforms, matrices and color stops

LibCompositing: Remove test tree builder calls that no test makes

LibCompositing: Remove visual context queries that C++ no longer asks

LibGfx: Remove cascade text shaping and GlyphRun::slice()

LibGfx: Remove the Gfx::Path operations that nothing uses

LibWeb: Remove pre-order navigation from Layout::Node

LibWeb: Stop copying generated text into its layout node

LibWeb: Remove the find-in-page blocks of SearchableText

LibWeb: Hand CSS strings to C++ as typed pointers

LibWeb: Take the VM by reference in the Rust bindings exports

LibWeb: Take FFI out-parameters as references and AK spans

LibWeb: Hand style values to Rust as OwnedArc and ArcRef

LibWeb: Take the objects C++ lends to FFI entry points by reference

LibWeb: Pass plain-value arrays through FFI as AK spans

LibWeb: Take objects C++ hands back as OwnedRc, OwnedArc and OwnedBox

LibWeb: Mark the custom ident style value constructor unsafe

LibGfx: Remove OwnedPath and the C++ path shims

LibWeb+LibCompositing: Use the native Path in Rust

LibCompositing+Compositor: Pass clip paths to the painter as contours

LibGfx: Lay out glyph outline paths in Rust

LibWeb: Hand Rust-built paths to C++ as bytes

LibWeb: Read the bounding box of an SVG shape from Rust

LibGfx: Add a native Path to libgfx_rust

LibWeb: Don't crash when closing a byte stream mid-element

LibWeb: Don't crash when pipeTo() shuts down before a queued write

LibWeb: Implement Streams in Rust

LibWeb: Support promises, callbacks and async iterables in Rust bindings

LibWeb: Let Rust constructors return the object they create

LibJS: Expose promises, iterators and native functions to Rust

LibMedia+LibWeb: Use checked arithmetic for byte parsing

LibMedia: Don't crash on bad WebM data

LibWeb: Implement TextEncoderStream and TextDecoderStream in Rust

LibWeb: Implement CompressionStream and DecompressionStream in Rust

LibCompress: Add a Rust crate for streaming compression

LibWeb: Accept any CSS color as the value of input type=color

Tests: Import WPT tests for input type=color

LibWeb: Implement Blob and File in Rust

Meta+LibWeb: Support Blob and File in the Rust bindings

LibURL+LibWebCommon+LibWeb: Process data: URLs in Rust

LibWeb+LibWebView+WebContent: Serve the WPT tree over HTTPS in test-web

LibWeb+WebWorker: Apply the embedder policy when a worker starts

LibWeb+LibWebCommon: Inherit a blob URL entry's policy container

LibWeb+LibWebCommon: Give local workers their owner's policy container

LibWeb: Base a window's cross-origin isolated capability on its cluster

LibWeb: Remove SharedArrayBuffer from realms that are not isolated

LibWeb+LibWebCommon+LibWebView: Send agent clusters' isolation modes

LibWebCommon+LibWebView: Give agent clusters an isolation mode

LibWeb+LibWebCommon+LibWebView: Check CORP on nested navigations

LibWebView: Check a navigation response's adherence to embedder policy

LibWebView: Hold the embedder policy of each document's policy container

LibWeb: Implement the cross-origin resource policy check

LibURL: Add "schemelessly same site"

LibWebView: Obtain a response's opener and embedder policies in the UI

LibWeb+LibWebCommon: Obtain an opener policy in LibWebCommon

LibWeb+LibWebCommon: Obtain an embedder policy from a fetch response

LibWeb+LibWebCommon+LibWebView: Share Fetch's URL scheme checks

LibWeb+LibWebCommon: Move the secure contexts checks into LibWebCommon

LibWeb: Parse Document-Policy as a structured field

LibWeb: Parse Cross-Origin-Opener-Policy as a structured field

LibHTTP: Add Fetch's "get a structured field value" to header lists

LibHTTP: Add a Structured Field Values parser

LibGfx+LibCompositing: Remove unused CornerClip

LibGfx: Remove unused CornerRadii code

LibGfx: Remove unused Path line helpers

LibGfx: Remove unused matrix helpers

LibGfx: Remove unused Size::match_aspect_ratio()

LibGfx: Remove unused Rect helpers

LibGfx: Remove unused Point helpers

LibGfx: Remove unused polar color conversions

LibGfx: Remove unused SVG gradient paint styles

LibGfx: Remove unused TextAlignment helpers

LibGfx: Remove unused Matrix3x3 helpers

LibGfx+LibCompositing+Compositor: Remove Gfx::Filter

LibGfx: Move ColorFilterType into its own header

LibGfx+Compositor: Keep paths in libgfx_rust instead of Skia

LibGfx: Add a path geometry to libgfx_rust

LibCompositing+Compositor: Keep a Skia path for each retained clip path

LibGfx: Don't leave a lone move before an appended path

LibGfx+Compositor: Parse ICC profiles in the compositor

LibGfx+Compositor: Move Skia surfaces and painting helpers to compositor

LibCompositing+Compositor: Move canvas surface registry to compositor

LibGfx+LibCompositing: Split the export formats out of BitmapExport.h

LibWebCommon+LibWeb: Implement MIME Sniffing in Rust

LibWeb: Apply the offset transform of CSS Motion Path

LibWeb: Interpolate and compose the offset properties

LibWeb: Add the CSS Motion Path offset properties

Tests/LibWeb: Import CSS Motion Path tests

LibGfx: Add Path::stroke_to_fill()

LibWeb: Follow the SVG rules for which elements are focusable

LibWeb: Parse the SVG values of the pointer-events property

Tests: Import WPT tests for SVG hit testing and pointer-events

LibWeb: Remove the C++ view of computed sizes

LibWeb: Resolve calc-size() in intrinsic sizes, flex, tables and images

LibWeb: Give replaced elements their natural height for size keywords

LibWeb: Interpolate sizing keywords through calc-size()

LibWeb: Implement calc-size() for sizing properties

LibWeb: Parse the interpolate-size property

LibWeb: Ignore namespaced event handler attributes

Meta: Point the Flatpak OpenSSL at the runtime's trusted roots

LibWeb: Preserve token counts through custom property substitution

LibWeb: Cache token counts for component-value lists

LibWeb: Use a hash set to track custom properties affected by animations

LibWeb: Reuse compiled custom function data during substitution

LibWeb: Resolve custom function visibility indices once per snapshot

LibWeb: Avoid unnecessary transaction management in `parse_node`

LibWeb: Avoid unnecessary work when parsing single token syntax types

LibWeb: Parse substituted component values directly

LibWeb: Borrow function-local registration syntaxes

LibWeb: Borrow tokens in parsed CSS boolean expressions

LibWeb: Borrow custom function declaration and default tokens

LibWeb: Use component values for arbitrary substitution functions

LibWeb: Parse registered syntax from component values

LibWeb: Reuse component values when constructing unresolved values

LibWeb: Cache computed element custom property values

LibWeb: Isolate guards when computing inherited custom properties

LibURL+LibWeb: Implement URL and URLSearchParams in Rust

LibURL+LibWeb: Implement Origin in Rust

Meta+LibJS+LibWeb: Support the URL interfaces in the Rust bindings

LibURL+LibWeb: Parse and serialize urlencoded forms in Rust

LibURL: Compute the origin of a URL in Rust

LibTextCodec+LibWeb: Share one streaming decoder with TextDecoder

LibTextCodec: Remove only the sniffed BOM when decoding

LibTextCodec: Encode through a fixed-size output buffer

LibTextCodec: Add an x-user-defined encoder

LibWeb: Mark the scroll state stale where scroll offsets are stored

LibWeb: Remove filter_from_functions() and the Rust export behind it

LibWasm: Simplify the engine and the JIT

LibWasm+LibWeb: Keep WebAssembly objects and waits right

LibWasm: Harden the runtime and the JIT

LibWasm: Add an AArch64 backend to the JIT

LibWasm: Turn the JIT on by default

LibWasm: Compile SIMD, GC, atomics and exceptions in the JIT

LibWasm: Run compiled code in the runtime, tiering up hot functions

LibWasm: Add an optimizing JIT compiler

LibWasm+LibWeb: Port the interpreter, and finish GC and exceptions