Hare 0.26.0 Ships With Uninitialized Memory and Error Ignoring

Hare 0.26.0 is out, and the systems programming language is making some... interesting choices.

For context: Hare positions itself as "simple and robust"—basically C but with fewer footguns and actual error handling. It's been shipping steady releases while everyone else argues about Rust vs Zig vs whatever C replacement dropped this week.

What Actually Changed

The release adds two features that are raising eyebrows:

Uninitialized memory support. You can now explicitly tell the compiler "don't zero this memory, I'll handle it." Performance optimization? Sure. Also the kind of feature that makes you question the "fewer footguns" pitch.

Error ignoring that looks like normal value ignoring. Previously, Hare forced you to handle errors explicitly. Now you can discard them using the same syntax as discarding any return value. One person's ergonomics improvement is another person's "wait, what?"

The Alpine Linux maintainer already upgraded it in edge, which either speaks to Hare's stability or Alpine's tolerance for adventure.

The Vibes Are Mixed

Lobsters discussion is split. Some devs are stoked about the UX improvements. Others are pointing out that adding "explicitly leave memory uninitialized" and "make errors easier to ignore" doesn't exactly scream "simple and robust."

One commenter nailed it: If you want the right amount of simple and robust, maybe start super conservative and gradually add pragmatic features. The alternative is accidentally becoming C++.

There's also chatter about whether Hare needs linear types for resource management. Currently it has defer (Go-style cleanup), but lacks language-level guarantees that you actually cleaned up. Usable? Yes. Perfect? TBD.

What Hare Actually Is

If you're new here: Hare is a statically-typed, manually memory-managed systems language. Think C semantics with modern error handling, tagged unions, and no NULL pointers. Functions are top-level only (no lambdas), it's got namespaces, and the FFI with C is seamless because it uses the C ABI.

No fancy borrow checker, no garbage collection, no async runtime. Just you, your pointers, and defer statements.

The Real Question

Is Hare staying true to its "simple and robust" roots, or slowly accumulating the same complexity creep that happens to every language that tries to be practical?

Version 0.26.0 suggests the latter might be starting. These features aren't inherently bad—performance matters, and forcing error handling on literally everything gets annoying. But they're also the exact kind of "tempting in isolation" additions that turn minimalist languages into Swiss Army chainsaws.

For now, Hare's still way simpler than most alternatives. The question is whether it stays that way or becomes another "well, we had to add this one thing" language.

Check the release notes if you want the full breakdown. Or just try it—the Alpine edge build is already live.