Ladybird Is Building a Browser From Scratch — and Saying No to AI Code

Here’s a quirk most people miss: almost every “new” browser you’ve heard of is really just Chrome wearing a different coat. Arc, Brave, even Microsoft Edge — crack them open and you’ll find Google’s Chromium engine humming inside. One project is pushing hard against that current. Ladybird is building an independent browser from the ground up — its own engine, its own rendering, no borrowed parts. And the most interesting question it raises isn’t about browsers at all: in an era where AI writes code on demand, does building something from scratch still mean anything?

A bit of honesty first. This isn’t a story that blew up on Hacker News in the last 30 days. It’s an ongoing project that resurfaces in tech circles again and again. So instead of chasing a news spike, it’s worth stepping back and understanding the context.

What Makes Ladybird “Independent”

Ladybird started with a developer named Andreas Kling. It grew up inside SerenityOS, a hobby operating system he was building, before spinning out into its own organization.

The core principle is zero dependencies. No Chromium. No Gecko, the engine behind Firefox. No WebKit, the one behind Safari. Ladybird parses HTML and paints pixels using code it wrote itself. Why is that a big deal? Because modern web standards are so sprawling that building a new engine was considered all but impossible. That’s the real reason no major new browser engine has appeared in over a decade.

The timeline is concrete: an alpha release aimed at everyday users in 2026. It’s structured as a nonprofit, with a stated commitment to never make money from ads or data collection.

Started in C++, but C++ Isn’t Safe

This is where the development philosophy gets interesting. Ladybird was originally written in C++. Fast, yes — but C++ makes humans manage memory by hand, which is exactly where security holes creep in. A browser is the front line of the internet, executing untrusted code from random websites all day. For that job, memory safety isn’t a nice-to-have. It’s everything.

So the team made a surprising call: new code would gradually migrate to Swift. Apple’s language raised a few eyebrows, but it was one of the rare options that guarantees memory safety while still playing nicely with existing C++. Rust is the more famous pick here, and the “why not Rust” debate ran hot for a while.

The decision matters because building from scratch isn’t stubbornness — it’s freedom of choice. Borrow someone else’s engine and you inherit their language, their architecture, their philosophy. Build your own foundation and a fundamental pivot like this becomes possible.

In the Age of AI Coding, Ladybird Won’t Take AI-Written Code

This is the part I find most striking. At a moment when ChatGPT and Copilot will spit out working code in seconds, Ladybird has stated it won’t accept AI-generated contributions.

The reasoning is simple and deep at once. A browser engine is code where a single small bug can become a security incident. AI tends to produce code that looks right and runs fine — but nobody, sometimes not even the person who submitted it, can fully explain why it’s written that way. When a contributor doesn’t truly understand what they’re handing in, the reviewers inherit all the burden of proving it’s safe.

You can see the fork in the road. On one side: the prevailing push to “10x your dev speed with AI.” On the other: a craftsman’s conviction that code you don’t understand is a liability, not an asset. Ladybird picked the second path. It’s less about rejecting AI outright and more about a single test — can a human take full responsibility for this code?

Between Recklessness and Reality

The skeptics aren’t wrong to push back. The most common critique: how can a small team ever catch up to Chromium, something Google poured thousands of engineers into? Web compatibility is a mountain, and climbing it is a brutal war of time and headcount.

And yet Ladybird draws attention partly thanks to some unexpected backers. Tech figures including Shopify’s CEO have put money in, and on GitHub the stars keep climbing as contributors pile in. That’s a lot of people who share one worry: is it healthy for a single engine to quietly own the entire web?

In the end, Ladybird’s bet is an honest illustration of a simple truth — independence has a cost. Borrow an engine and you move fast but stay dependent. Build your own and you move slow but stay free.

What makes the choice fascinating is the timing. In an era where speed is treated as a virtue unto itself, Ladybird deliberately chose the slower road — the one where you actually understand what you built. So which pulls at you more: code an AI writes 10 times faster, or code you own line by line? For software where trust is the whole point, like a browser, where does your gut land?