Jenny’s Daily Drivers: SerenityOS, And In Particular, Ladybird

Every so often, a project shows up that feels like it escaped from two different timelines at once:
one where your desktop still has chunky icons and unapologetically rectangular buttons, and another where someone decided,
“You know what the world needs? A brand-new browser engine… built from scratch.”

That’s the vibe behind SerenityOS and its famous “offspring,” Ladybirdand it’s exactly why Jenny List’s
Daily Drivers series took a detour to visit them. Her verdict (translated from “Hackaday voice” to “human voice”) was basically:
“Not a daily driver yet… but it’s too interesting to ignore.” And honestly? Same.

SerenityOS in one sentence: the dream of the ’90s, with a Unix-like core

SerenityOS describes itself as a graphical, Unix-like desktop operating system that’s a love letter to ’90s user interfaces,
paired with a custom Unix-like corestealing good ideas with sincerity and making them feel coherent again.
Think late-1990s productivity software aesthetics, but with the power-user sensibilities of later *nix systems.

The big twist is scope: SerenityOS isn’t “a desktop environment” or “a distro.” It’s a from-scratch system that aims to own the
whole stackfrom kernel to GUI to developer tools to (yes) web browserleaning hard into building things in-house.
That philosophy is both its superpower and its self-imposed boss fight.

Where it came from (and why the birthday matters)

SerenityOS has been in continuous public development since its first repository commit on October 10, 2018.
In the project’s own “birthday” write-up, Andreas Kling frames SerenityOS as a from-scratch desktop OS with a Unix-like core,
and calls out the “kernel to web browser” ambition as part of the pointnot a side quest.

If you want a neat mental shortcut: SerenityOS is what happens when “I want to understand everything” becomes a community project.
It’s nostalgia, surebut it’s also a very modern kind of engineering curiosity.

Why Jenny cared: Ladybird is the real headline

SerenityOS is charming. But Ladybird is the part that makes people sit up straighter.
It’s a browser project that’s explicitly aiming to be modern, capable, and cross-platformwithout being “Chromium with a new logo”
or “WebKit in a trench coat.”

In Jenny’s write-up, she calls out the key differentiator: Ladybird is trying to become a fully capable browser from scratch,
rather than yet another appliance built on an existing major engine. That matters because the web runs on browser engines,
and engine diversity is basically a public health issue for the internet.

The browser monoculture problem (in plain English)

If most browsers share the same engine DNA, then one implementation (and one set of incentives) quietly becomes the “real web.”
Websites start shipping “works in Engine X” as a substitute for standards compliance, and everyone else has to chase.
Even when that dominant engine is technically excellent, monoculture increases risk: bugs become universal, performance quirks become norms,
and standards debates get distorted by “well, it already works in the main engine.”

Ladybird’s stated goal is to be a standards-first, people-first browser backed by a nonprofit, explicitly rejecting business models
like default search deals and other forms of user monetization. That’s not just a technical stanceit’s governance.

What Ladybird actually is today (and what it isn’t)

Let’s be clear: Ladybird is pre-alpha and the project itself labels it as suitable primarily for developers right now.
That’s not a diss; it’s a reality check. Browsers are absurdly complicated, and honesty is refreshing.

Technically, Ladybird is built on SerenityOS-originated components like LibWeb (rendering/DOM/layout) and
LibJS (JavaScript engine), and Serenity’s own documentation describes Ladybird as a web browser built on those engines.
The same documentation also notes the UI path: a cross-platform GUI using Qt6 and a macOS-specific GUI option.
Translation: it’s not trapped inside SerenityOS anymore; it’s trying to be a real desktop browser where people actually live.

“Spun out” and growing up fast

SerenityOS’s own five-year reflection describes how Ladybird was spun out as a cross-platform applicationno longer confined to the OS
and points to accelerated progress after that transition. Meanwhile, Ladybird’s public announcement post says they can already do
some everyday browsing tasks with it (think GitHub and Hacker News), while still being upfront that it’s far from finished.

This combinationit works for some real tasks + it’s not ready, don’t pretend it isis the healthiest possible energy
for a project of this size.

Jenny’s hands-on: SerenityOS feels stable… until the browser starts eating RAM

Jenny’s SerenityOS experience is peak “this is weirdly polished for a hobby OS.” She built it from source, launched it in QEMU,
and found herself in a desktop that could pass for a Windows 9x lookalikeespecially if you pick the “Redmond” theme.
The important part: it didn’t feel like a fragile demo. It felt like an OS that wants to be used (inside its sandbox).

SerenityOS doesn’t typically present itself as “download an ISO and install it on your laptop.” The build-and-run flow is a feature,
not a bug: the project’s build instructions are designed to build a disk image and launch SerenityOS in QEMU for you,
and the community has historically been blunt that you’re expected to build it yourself if you want to try it.

Jenny also poked at the Ports ecosystem: a curated, developer-interest-driven collection of software,
where installing a port can mean “run the build script and bake it into the image.” She tried a game (Tux Racer),
and it workedbecause of course the ’90s desktop needs a little chaotic joy.

Ladybird inside SerenityOS: impressive… and sometimes crashy

Here’s where the story turns: running Ladybird inside the default SerenityOS QEMU setup was rough for Jenny.
She observed memory draining until crashes on anything but simple sitesless “this engine is doomed” and more
“QEMU defaults don’t reflect real-world 2023+ browsing.”

So she did the fairest thing possible: she built Ladybird to run natively on Linux, where it could stretch its legs.
That’s when the promise showed. In her tests, Ladybird loaded real sites acceptably, and even posted a strong
Acid3 score (she cites 96/100, noting that Chrome and Firefox were 97 in that context).
In other words: not a toy. Not “done.” But not a toy.

Under the hood: building a new browser engine is like rebuilding a city… while people drive through it

To appreciate Ladybird, it helps to understand the job description of a browser engine. A modern browser has to:

• Parse HTML, CSS, and JavaScript at scale, fast and correctly.
• Build a DOM tree, run layout, paint pixels, and keep it all responsive.
• Implement web APIs that are effectively “the operating system of the internet.”
• Handle security boundaries, sandboxing, permissions, and increasingly complex media formats.
• Stay compatible with a web that never forgets anything.

Ladybird’s strategy is notable: it positions itself as standards-first and explicitly independent, avoiding code from Blink/Chromium,
WebKit/Safari, Gecko/Firefox, or any other engine. That’s a bold constraintbut it’s also the point.
If you want true engine diversity, you need at least one project willing to do the painful, unglamorous work.

Standards work isn’t just “passing tests”it’s shaping the web

One underappreciated benefit of alternative engines is feedback. When a fresh implementation hits the same spec text and gets stuck,
it often reveals ambiguities or assumptions that big engines have papered over with legacy behavior.
SerenityOS developers have highlighted that “code close to the spec” can lead to discovering and reporting issues in standards work,
which is exactly the kind of ecosystem value that doesn’t show up in a marketing slide deck.

A culture shift: SerenityOS builds everything; Ladybird is learning when not to

SerenityOS has a strong “build it ourselves” culture. That’s funand it creates accountability.
But it also means reinventing wheels that other projects have already made round, battle-tested, and security-audited.

Ladybird’s own FAQ and messaging acknowledge the shift: after forking/spinning out from SerenityOS, Ladybird is no longer bound by
the same “everything in-house” culture and intends to use third-party libraries for common functionality
(things like media formats, crypto, graphics, and so on). Community discussion has pointed out examples of replacing home-grown
components with established libraries like OpenSSLexactly the kind of pragmatic move you make when you’re trying to become a browser
people can use daily, not just admire.

This matters for credibility. Users don’t choose a browser because it heroically implements its own everything.
They choose it because it’s secure, fast, compatible, and dependable.

Roadmap: ambitious, specific, and refreshingly public

Ladybird’s published roadmap targets:
alpha in Summer 2026 for Linux and macOS (aimed at developers and early adopters),
a beta in 2027, and a stable release in 2028.
That’s a long runwayand it should be. The web isn’t a weekend project.

A useful way to read this roadmap is not “will they ship on that exact date?” but “are they thinking like a real product?”
The answer appears to be yes: they talk about security policy maturity, vulnerability handling, and the boring-but-critical processes
that separate a demo from something you trust with your passwords.

So… will Ladybird become a daily driver?

“Daily driver” is less about vibes and more about non-negotiables. A daily driver browser has to:

1. Work on your web: banking, docs, video, auth flows, weird corporate SSO, and the one site you hate but must use.
2. Be safe: sandboxing, patch cadence, responsible disclosure, and secure defaults.
3. Be fast enough: not necessarily “wins benchmarks,” but “doesn’t feel like it’s thinking in slow motion.”
4. Respect you: privacy posture, no creepy incentives, and transparency about funding.
5. Have an ecosystem plan: extensions, devtools, accessibility, internationalization.

Ladybird is openly working its way up that ladder. The nonprofit backing, the explicit rejection of user monetization,
and the standards-first positioning are strong signals. The huge challenge is compatibility: the web is messy, and “standards-compliant”
is sometimes not enough when sites ship engine-specific quirks as if they’re laws of physics.

Still, even partial success has value. A healthier browser ecosystem doesn’t require Ladybird to “replace Chrome.”
It requires Ladybird to exist, improve, and provide competitive pressureand to give standards bodies and web developers another
serious implementation to care about.

What SerenityOS contributes to Ladybird’s story

SerenityOS is not just a quirky retro OS; it’s an engineering incubator. Building an OS from scratch forces rigor:
libraries, graphics, networking, tooling, debuggingeverything is “real” because you can’t shrug and say,
“the platform handles that.” That discipline bleeds into the browser work.

Jenny’s review captured the practical version of that: SerenityOS felt stable and coherent inside its intended sandbox,
and its browser effort wasn’t a gimmickit was a serious project with visible progress.
SerenityOS also makes the browser’s complexity easier to grasp, because you can see the whole environment it came from.

Final take: the most interesting “not yet” on the internet

If you’re looking for something you can install tomorrow and use for everything, SerenityOS and Ladybird will (politely) tell you:
not yet. Jenny’s “Daily Driver” detour makes sense precisely because it’s honest about that.

But if you’re looking for a project that could reshape the browser conversationby existing, by shipping a new engine,
and by proving that the web doesn’t have to be a two-engine monarchythen Ladybird is worth following.
And SerenityOS is the delightfully retro, unexpectedly solid world where that story began.

Experiences: A (Very) Realistic Week with SerenityOS and Ladybird

Let’s talk “experience,” because that’s the part that turns a clever project into a lived-in tool. Imagine Jenny’s week as a
practical experiment: not “I’m moving in forever,” but “I’m spending enough time here to learn what it gets rightand what still bites.”

Day 1: The first win is emotional, not technical. The SerenityOS desktop boots and your brain does the time-travel thing.
The icons are friendly. The window chrome is unapologetic. You pick the “Redmond” theme and suddenly you’re expecting a dial-up modem
sound effect. Then you open a terminal andsurpriseit’s not cosplay. It’s Unix-like, with real conventions, and it feels consistent.
Jenny’s notes would read: “This looks like 1996, but it behaves like a system written by people who actually use computers.”

Day 2: You start doing “small life” tasks. Open a text editor. Move files around. Poke at system utilities.
SerenityOS shines here because it’s cohesive: the apps look like they belong together, and the OS doesn’t feel like a pile of unrelated demos.
The joke writes itself“It’s like the ’90s, but with fewer printer drivers ruining your weekend”except that the printer driver part is also true:
you’re not on bare metal, you’re in a VM, and you’re safe from the chaos of reality.

Day 3: Now you get brave. You try the ports ecosystem. It’s not an app store; it’s more like a curated potluck.
Someone brought tools. Someone brought games. Someone brought “an emulator you didn’t know you needed until you saw it.”
Installing something feels delightfully hands-on, and when a game runs, it’s weirdly satisfyinglike you helped the OS earn it.

Day 4: Browsing day. Inside the default VM setup, Ladybird is the dramatic friend who shows up charming and then eats all the snacks.
Pages start loading, the layout looks promising, and thenoopsresources run out. The lesson isn’t “bad browser,” it’s “browsers are hungry”
and virtual machines don’t automatically mirror modern hardware expectations. Jenny’s practical move (and the one you’d copy) is to build Ladybird
natively on a host OS where it can access real memory and real performance headroom.

Day 5: Native Ladybird is the “ohhh, I get it” moment. It’s still early, still developer-focused, and still imperfect,
but the vibe changes from “cute experiment” to “serious direction.” You can open real sites. You can do light tasks.
You begin noticing where things fail, not as a disappointment, but as a map: missing APIs, rough edges in rendering, performance work ahead.
You start rooting for it the way you root for a team that’s rebuilding: not because they’re winning today, but because you can see the system
taking shape.

Day 6: The novelty fades and the truth arrives: daily-driver readiness is boring. Password managers. Video calls.
Web apps with complex editor components. Accessibility. Extensions. “Sign in with…” flows that involve three redirects and a captcha.
This is where Jenny would realistically fall back to her normal browser for work, while still using Ladybird for deliberate testing.
And that’s a compliment. Being used as a “real task browser” even part-time is a milestone for a project at this stage.

Day 7: The week ends with clarity. SerenityOS is the delightful retro laboratory where coherence is a feature.
Ladybird is the ambitious, modern bet: an independent engine with a governance story (nonprofit, anti-monetization posture) that’s as interesting
as the code. Jenny’s week wouldn’t end with “I switched forever.” It would end with “I’m keeping this on my radar, because the web needs this kind
of projectand because watching it grow is half the fun.”