Get AI summaries of any video or article — Sign up free
Making A Browser Is Harder Than You Think (Ft Andreas Kling) thumbnail

Making A Browser Is Harder Than You Think (Ft Andreas Kling)

The PrimeTime·
6 min read

Based on The PrimeTime's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Ladybird began as a Serenity OS rich-text experiment (HTML/CSS) and later split into a separate browser project when the combined OS+browser contributor needs became incompatible.

Briefing

Ladybird’s lead developer, Andreas Kling, frames browser-building as a long, grinding engineering problem—one that starts with “from-scratch” web standards work but quickly becomes dominated by compatibility, spec churn, and maintenance. The browser began as a small project inside Serenity OS—initially aimed at rendering rich text via HTML and CSS—then grew into a standalone effort when the combined operating system + browser codebase became too socially and technically mismatched for contributors, testing, and CI.

Kling traces Ladybird’s evolution from a hobby to a community-backed project with over a thousand contributors to Serenity OS, and a separate browser effort focused on shipping a real engine. Ladybird is built to implement core web specifications—HTML, CSS, JavaScript, and supporting standards like URL encoding—while selectively using third-party libraries for areas outside the team’s core expertise. For graphics, the project moved from its own stack to Skia; for networking it uses curl; and for GPU/GL context handling it relies on an angle library approach to avoid writing low-level platform glue for every target.

A major emphasis is JavaScript compliance. Kling says Ladybird’s JavaScript engine (LiJS) is highly compliant with the TC39 test suite Test262, citing a recent top score around 97% and noting that Firefox briefly pulled ahead after a code dump for the Temporal proposal. He also stresses that “spec compliance” doesn’t automatically translate to perfect real-world compatibility, because the web’s behavior is shaped by countless interactions among features.

CSS is presented as the most chaotic part of the platform. Kling describes the mental-model traps that arise from layout rules—especially when widths, heights, and percentages depend on each other—and the way CSS specs keep evolving. He estimates major “earth-shaking” spec rewrites happen only once or twice per year, but the day-to-day changes still force constant revalidation. Ladybird’s approach is to keep scope manageable, accept that many fixes can break other combinations, and prioritize what breaks in practice.

On usability, Kling is blunt: Ladybird is pre-alpha and not suitable for average daily browsing. He personally tests it by opening random links and tracking what fails, with GitHub workflows working better than most public sites. He highlights user-agent string decisions as a practical pain point—Ladybird avoids lying by default, but that can break sites that gate behavior on browser identity.

The conversation also widens into antitrust and funding realities. Kling argues that if Google’s Chromium dominance is disrupted, standards work and browser development capacity could stall because much of the ecosystem’s engineering and money is concentrated around Chromium. He hopes new engines will emerge to restore choice, and he cites Servo as another engine effort that has faced instability but is restarting after Linux Foundation support.

Finally, Kling explains why Ladybird is funded as a nonprofit with constrained sponsorship: logos and public credit, not influence. He says the team stays small to avoid becoming dependent on any single donor, and he positions the next major hurdle as maintenance—an “infinitely long tail” of keeping pace with a living web platform. Ladybird’s roadmap includes an alpha release target in 2026, with the expectation that feedback will become more meaningful once the browser is closer to real-world use.

Cornell Notes

Ladybird started as a Serenity OS project to display rich text using HTML and CSS, then grew into a standalone browser when the combined codebase became too hard to coordinate. Kling says Ladybird implements core web standards (HTML, CSS, JavaScript, URL encoding) while using third-party libraries for non-core infrastructure like graphics and networking. JavaScript compliance is strong, with LiJS scoring around 97% on the TC39 Test262 suite, though real-world compatibility still depends on complex interactions across specs—especially CSS. Kling emphasizes that CSS is a continual mental-model and spec-churn challenge, and that Ladybird is pre-alpha and not ready for average daily use. The broader motivation is restoring browser choice and reducing dependence on Chromium, particularly amid potential antitrust fallout and concentrated funding.

Why did Ladybird split off from Serenity OS, and what problem did that solve?

Kling describes both technical and social scaling issues. Contributors wanted to work on very different kinds of tasks—device drivers and OS features versus browser work like JavaScript optimizations and GPU rendering. Putting everything into one CI pipeline meant running huge browser test suites alongside driver work, and the shared bug tracker became unmanageable. Separating the projects let OS-focused contributors stay in Serenity and browser-focused contributors move to Ladybird, which Kling calls a healthier split even if the projects remain conceptually related.

What does “from scratch” mean for Ladybird, and where does it still rely on third-party components?

Kling says Ladybird is not a Chrome or Firefox reskin and is not built on top of an existing browser engine. The project implements web-facing specifications itself—HTML, CSS, JavaScript, and supporting standards like URL encoding. But for infrastructure outside the team’s core interest, it uses established open-source libraries: Skia for graphics, curl for networking, and angle for providing an OpenGL ES3 context across platforms. The goal is to avoid reinventing low-level platform glue while still owning the web engine behavior.

How does Ladybird measure JavaScript engine progress, and what test suite is used?

Progress is measured using TC39’s Test262 compliance suite. Kling says LiJS has been highly compliant, recently scoring around 97% and even reaching the highest score until Firefox pulled ahead after a Temporal proposal implementation code dump. He also notes that chasing spec test numbers is partly a nerd-driven motivation, but compatibility still requires more than passing every corner of the spec.

Why does CSS create so much engineering churn for Ladybird?

Kling points to both layout complexity and the living nature of CSS specs. He highlights mental-model problems such as when widths can be resolved from heights, especially with percentage-based sizing where the order of evaluation matters. He also describes CSS as continuously updated: sometimes specs clarify ambiguity, but sometimes they add new properties or values that force major rework. He estimates major rewrites that “wreck” the implementation happen only once or twice per year, but smaller changes and new feature interactions keep breaking previously working combinations.

What is Ladybird’s current usability status, and how does Kling test it day-to-day?

Kling says Ladybird is completely unusable for the average user and guarantees dissatisfaction. It’s pre-alpha by design, and he tests it by trying to open random websites from links people send him, tracking what breaks. GitHub-based workflows work better because they’re heavily tested, while many public sites fail due to unimplemented CSS features or unusual combinations. He also mentions that user-agent string handling is a constant source of pain: Ladybird prefers not to lie about its identity, which can cause sites to refuse or degrade functionality.

How does antitrust risk and Chromium concentration factor into Ladybird’s mission?

Kling argues that if Google’s role in Chromium is constrained or disrupted, multiple effects could follow: Chromium engine development would need replacement, and standards work—often staffed by Google employees—could slow or stall. He also describes secondary funding impacts, since other browsers rely on revenue streams tied to Chromium’s dominance. This concentration is part of why he wants new engines and more choice, and why Ladybird is exploring a browser development model that doesn’t require a billion-dollar budget.

Review Questions

  1. What specific scaling and coordination issues made a single Serenity OS + browser repository untenable?
  2. How does Ladybird balance “from scratch” web engine ownership with third-party libraries for graphics and networking?
  3. Why does Kling consider CSS both a spec-churn problem and a mental-model problem, and what example layout dependency illustrates that?

Key Points

  1. 1

    Ladybird began as a Serenity OS rich-text experiment (HTML/CSS) and later split into a separate browser project when the combined OS+browser contributor needs became incompatible.

  2. 2

    Ladybird implements core web standards itself (HTML, CSS, JavaScript, URL encoding) while using third-party libraries for non-core infrastructure like graphics (Skia), networking (curl), and OpenGL ES3 context support (angle).

  3. 3

    LiJS JavaScript compliance is tracked with TC39’s Test262 suite, with recent scores around 97% and periodic shifts when other engines land major proposal implementations.

  4. 4

    CSS is described as the biggest compatibility and engineering churn driver due to complex layout evaluation rules (including percentage dependencies) and an evolving, continuously updated spec.

  5. 5

    Ladybird is pre-alpha and not positioned as a daily driver; Kling tests it by opening random links and focusing on what breaks, with GitHub workflows working best.

  6. 6

    Potential antitrust outcomes affecting Chromium could slow standards work and engine development because much of the ecosystem’s engineering and funding is concentrated around Google.

  7. 7

    Ladybird’s nonprofit funding model aims to preserve independence by accepting donations and sponsorship credit without selling influence, while keeping the team small to avoid donor dependency.

Highlights

Ladybird’s browser work grew organically from “bold text on screen” into a full engine—then split off from Serenity OS because CI, testing, and contributor goals didn’t scale together.
Kling cites Test262 compliance for LiJS, including a recent ~97% score and a brief lead shift when Firefox landed Temporal work.
CSS is portrayed as uniquely dangerous: fixing layout rules can break many other combinations, and spec updates force ongoing mental-model rewrites.
Kling’s usability stance is uncompromising: Ladybird is pre-alpha and “completely unusable” for average users, though GitHub workflows are a current bright spot.
The mission extends beyond engineering: Kling links browser choice to antitrust and funding concentration around Chromium, arguing that standards work could stall if that ecosystem is disrupted.

Topics

  • Ladybird Browser
  • Serenity OS
  • JavaScript Compliance
  • CSS Layout
  • Browser Engines
  • Antitrust
  • Nonprofit Funding

Mentioned