Half-Life 2 runs natively on Haiku after a hobbyist ports Nvidia's Turing driver

4 min read 1 source clear_take
├── "Nvidia's open-sourcing of GPU kernel modules is what made this hobby-OS port tractable"
│  └── top10.dev editorial (top10.dev) → read below

The editorial argues that Nvidia's May 2022 dual MIT/GPL release of open-gpu-kernel-modules is the enabling event here. Because the GSP firmware handles most of the heavy lifting on-chip, the host driver is largely a message-passing shim — kernel-agnostic enough that a single-digit team of Haiku volunteers could realistically port it.

├── "Turing-and-newer support is existentially important for Haiku's viability"
│  └── top10.dev editorial (top10.dev) → read below

The editorial frames Haiku's inability to drive any GPU made after 2015 as an existential problem for a hobby OS. Getting a native Half-Life 2 build talking to real RTX 20-series silicon — not Wine-in-a-VM — finally breaks the framebuffer ceiling and gives the project a credible path to running modern GPU-accelerated software.

└── "Running a real Source-engine game natively is the meaningful proof point"
  └── @m0do1 (Hacker News, 286 pts) → view

By surfacing the page-18 forum thread specifically at the Half-Life 2 milestone, the submitter treats the native Source engine boot as the headline achievement rather than any of the earlier driver progress. The implicit argument is that a non-trivial 3D workload rendering end-to-end on real Turing silicon is what turns an incremental porting effort into a demonstrable, credible result.

What happened

A developer on the Haiku forums has demonstrated Half-Life 2 running natively on Haiku, the open-source spiritual successor to BeOS, powered by a work-in-progress port of Nvidia's Turing-generation GPU driver. The thread — now 18 pages deep — tracks the incremental porting of Nvidia's `open-gpu-kernel-modules` to Haiku's kernel, with the Source engine as the first non-trivial 3D workload to boot end-to-end.

This isn't Half-Life 2 running under Wine on Linux running in a VM on Haiku — it's the native x86_64 build talking to a native Haiku Nvidia driver on real Turing silicon (RTX 20-series). The screenshots show Gordon Freeman rendering at usable frame rates on hardware that, until this year, Haiku couldn't drive past a framebuffer. The port targets Turing specifically because that's the oldest generation Nvidia's open kernel modules support; Pascal and earlier remain stuck on the closed blob, which is a non-starter for a hobby OS with no NDA relationship.

The work builds directly on Nvidia's May 2022 decision to open-source its GPU kernel modules under a dual MIT/GPL license. That release was aimed at Linux distros, but the code is deliberately kernel-agnostic in the parts that matter — the GSP (GPU System Processor) firmware does most of the heavy lifting on-chip, and the host driver is largely a message-passing shim. That architecture is what made this port tractable for a single-digit team of volunteers.

Why it matters

The Haiku project has spent two decades in a strange loop: technically impressive microkernel-adjacent design, a genuine BeOS lineage, and a community that ships steady alpha releases — but no path to running modern GPU-accelerated software. Every previous attempt to build a modern Nvidia driver hit the same wall: the closed userspace stack assumed Linux-specific ABIs and Nvidia had zero interest in helping port it. For a hobby OS, "we can't render a triangle on hardware made after 2015" is an existential problem — no browsers with GPU compositing, no video decode, no games, no future.

Nvidia's open-source pivot was pitched at the time as a concession to the Linux desktop community, and the immediate beneficiaries were distros wrangling with Wayland and secure boot. The Haiku port is the sleeper case for why opening the kernel driver mattered beyond Linux. Any OS with a competent kernel team and enough patience can now, in principle, drive modern Nvidia hardware — the moat wasn't the silicon, it was the source code. That's true in a way it simply wasn't for AMD (which has had open drivers forever but a smaller volunteer pool interested in porting them) or Intel (same story).

The HN thread on the demo is worth reading for the community reaction, which is split between genuine delight and a sober "this is one person, on one GPU generation, and the driver is nowhere near feature-complete." Both are correct. Vulkan is not working yet. Multi-monitor is spotty. Power management is a TODO. The Turing-only limitation cuts out the entire installed base of pre-2018 Nvidia cards and everything AMD. But the load-bearing claim — that a native Nvidia driver on a non-Linux, non-Windows OS is now a solvable engineering problem instead of a legal one — holds.

Compare this to the situation on FreeBSD and OpenBSD, which have wrestled with the same problem for years. FreeBSD gets Nvidia's blessing via a native binary blob, but it's always a version or two behind Linux and depends on Nvidia's continued goodwill. OpenBSD has essentially given up on modern Nvidia. Haiku, starting from further behind, may end up with a better story than either — a fully in-tree, source-available driver stack that the project controls end to end.

What this means for your stack

Realistically, nothing in your production stack changes because of this. Haiku is not going to displace your Ubuntu servers or your MacBook. But if you've been writing off Haiku, ReactOS, SerenityOS, and the rest of the hobby-OS ecosystem as museum pieces, this is the moment to reassess — the open-driver era means these projects can, for the first time, catch up on hardware support without a corporate patron.

For developers who care about the shape of computing outside the Linux/Windows/macOS trichotomy, the practical implication is that experimenting on Haiku is now less of a dead end. You can build a native app, hit real GPU acceleration, and demo it on real hardware. That's the minimum bar to attract the kind of contributor who actually ships things, and Haiku just cleared it. The project's package manager (HaikuPorts, Haiku-native `.hpkg`), its native API, and its POSIX layer are all mature enough that a competent C++ or Rust developer can be productive in a weekend.

There's also a lesson for anyone shipping hardware or drivers commercially. Nvidia opened these modules under pressure and skepticism, and the immediate ROI was measured in Linux distro compatibility patches. Three years later, a side effect is that a BeOS successor renders Half-Life 2 natively. Open-sourcing infrastructure creates option value you cannot forecast — the Haiku port would have been a 20-year impossibility under the old licensing regime and became a weekend-project-scale problem under the new one.

Looking ahead

Expect the Haiku driver to grow Vulkan support next — the open kernel modules already expose the necessary interfaces, and the userspace Mesa stack is portable enough that a Haiku backend is more grunt work than research. Once Vulkan lands, the door opens to Proton-style Windows-game compatibility, browser GPU compositing, and eventually the kind of creative software (Blender, DaVinci Resolve) that would give Haiku a genuine niche beyond nostalgia. None of that is imminent. But for the first time in the project's history, the roadmap doesn't end at a closed-driver wall.

Hacker News 323 pts 66 comments

Half-Life 2 running natively on HaikuOS

→ read on Hacker News

// share this

// get daily digest

Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.