Blogs on The Hare programming language

Hare 0.26.0 released

Fri, 13 Feb 2026 00:00:00 +0000

I am proud to announce the release of Hare 0.26.0 today. 🎉 This is the latest stable Hare release since last year’s release of Hare 0.25.2. This new release includes a handful of new features and a modest number of bug fixes and minor improvements.

We were also pleased to welcome Joe Finney as the latest Hare maintainer during this release cycle! Joe has been a steadfast contributor and code reviewer for Hare for some time now and it’s a pleasure to formally invite him to the maintainer team.

Hare meetup at FOSDEM 2026

Thu, 22 Jan 2026 00:00:00 +0000

The Hare community is hosting a meetup at FOSDEM 2026 and we would love to meet you there and discuss your projects and the direction of the Hare programming language in the coming year.

We will be meeting in UA4.228 at 14:00 on Saturday: check the schedule.

See you there!

Introducing builtwithhare.org

Fri, 22 Aug 2025 00:00:00 +0000

One of the Hare community’s shared values is a belief in the importance of good documentation. haredoc is a great and accessible resource both for writing and reading documentation – you can just comment your code to produce docs, and reading them is just a few keystrokes away in your terminal emulator.

$ haredoc os::create
// Creates a new file with the given mode if it doesn't already exist and opens
// it for writing.
//
// Only the permission bits of the mode are used. If other bits are set, they
// are discarded.
//
// The return value is an unbuffered [[io::file]]. For buffered I/O, see
// [[create_buffered]]. To create a file without opening it, see [[mkfile]].
fn create(
        path: str,
        mode: fs::mode,
        flags: fs::flag = fs::flag::WRONLY | fs::flag::TRUNC,
) (io::file | fs::error);

Docs written with haredoc can also be formatted for the web, and the standard library documentation available here on harelang.org is based on this approach. However, this can only get you so far – publishing haredocs on the web requires having a place to host it, a domain name and some kind of web hosting – and haredocs are not a comprehensive solution for good documentation.

Upcoming changes to Hare's event loop library

Wed, 30 Jul 2025 00:00:00 +0000

hare-ev is an important Hare library that provides an event loop for Hare programs, similar to libuv, which most Hare programs which perform asynchronous I/O depend on for that purpose. I’ve been working on some design improvements over the past couple of weeks which will introduce major breaking changes, but also bring many important features – I’d like to share these with you now.

Highlights include:

More direct control over ev’s memory management
Support for multiple uniform I/O requests in-flight at once
Support for parallelization of certain non-uniform I/O requests, e.g. send and recv
Idempotency of request cancellation and reuse of request objects
Improved support for high-level I/O requests, e.g. DNS queries or HTTP requests

To assist in migrating your code to adapt to the changes, and to introduce these new features, let’s go over them in detail now.

Hare 0.25.2 released

Sat, 21 Jun 2025 00:00:00 +0000

I am pleased to announce the release of Hare 0.25.2 today. 🎉 It has been almost one year since the previous release, Hare 0.24.2, and the new release is packed with the numerous language features, standard libarary features, and countless bugfixes and small improvements which have been implemented since. I’m excited to share the highlights with you today.

Hare 0.25.2

Release notes: Hare 0.25.2
Download: compiler harec-0.25.2.tar.gz • stdlib hare-0.25.2.tar.gz

Hare 0.25.2 is compatible with version 1.2 of qbe.

hare-update assists in addressing breaking changes in your code

Wed, 11 Jun 2025 00:00:00 +0000

We’re working on a new tool to release along the next upcoming stable release of Hare (likely Hare 0.25.2, or 0.25.3, following our release policy) – hare-update. The coming Hare release includes a number of small breaking changes, as per usual during Hare’s development phase, but one in particular is relatively odious for users to deal with: nomem.

Handling error cases is mandatory in Hare, even if you just assert on error (terminating the program) – you have to do something about errors. However, failure to allocate memory has long been an exception to this rule, and in many cases it was not possible for Hare programs to handle this sort of failure properly. The “nomem” patches which Pasta landed in Hare master several months ago addresses this oversight, but in so doing all allocations throughout the Hare ecosystem can now return errors that they previously would not and which programmers are required to modify their code to address.

A tour of upcoming RFCs

Mon, 02 Jun 2025 00:00:00 +0000

As part of our goal to become a 100-year programming language, Hare’s grammar and semantics will be frozen upon reaching version 1.0. But, before that point in time, we will make occasional breaking changes to introduce new features and fix Hare’s present shortcomings. This process allows us to become more confident in Hare’s long-term viability now, before we commit to the same design indefinitely. To make this easier on Hare programmers, we are working on a tool to assist in migrating codebases to address breaking changes.

Hare 0.24.2 released

Sun, 14 Jul 2024 00:00:00 +0000

I am pleased to announce the release of Hare 0.24.2 🎉. This release comes with new language features, improvements to the standard library, and a healthy dose of breaking changes. Let’s go through the highlights together.

Hare 0.24.2

Release notes: Hare 0.24.2
Download: compiler harec-0.24.2.tar.gz • stdlib hare-0.24.2.tar.gz

Hare 0.24.2 is compatible with version 1.2 of qbe.

New here? Hare is a systems programming language designed to be simple and robust, using a static type system, manual memory management, and a minimal runtime. You can learn about it here.

Introducing for-each loops for Hare

Tue, 02 Apr 2024 00:00:00 +0000

Today, for-each loops were merged into Hare’s development branch! This includes patches for the compiler, standard library, specification and tutorial. I want to give some background on how we designed for-each loops and what challenges are associated with implementing them.

What kind of for-each loops do we want?

Before for-each loops, you could iterate over an array/slice like so:

let array = [1, 2, 3];
for (let i = 0z; i < len(array); i += 1) {
	fmt::printfln("{}", array[i])!;
};

Having an index can be very powerful if you require it. However, in most cases, you will not, and I’ve found that using indices makes code less readable. This is how a for-each loop over an array/slice could look:

Online documentation improvements for harelang.org

Mon, 26 Feb 2024 00:00:00 +0000

This morning, I put the finishing touches on and shipped a new set of online docs for harelang.org — check it out! The bulk of the changes live at harelang.org/documentation/, and include a shoring up of many under-documented areas of Hare usage, such as cross-compiling and freestanding support, pulls together a disparate patchwork of documentation littered across Hare’s ecosystem into a cohesive quilt, and presents it all in a much more accessible and navigable manner.

Hare 0.24.0 released, and Hare's new release policy

Fri, 16 Feb 2024 00:00:00 +0000

Hare’s first versioned release, 0.24.0, was tagged and shipped today. 🎉 We have written up a new release policy for Hare to govern this and future releases. Here’s the rundown on how this is going to work.

New here? Hare is a systems programming language designed to be simple and robust, using a static type system, manual memory management, and a minimal runtime. You can learn about it here.

Hare is currently at a level of sophistication where it is useful for many kinds of projects, and is being used for those projects. Many Hare users want to ship their Hare projects to users, and as such, software written in Hare is making its way into Linux distributions and the like. However, due to Hare’s unstable nature, we have not provided any versioned releases, forcing any distributions who want to package Hare to package Hare’s master branch, which is less than ideal. We also have no good means of distributing news of breaking changes, or tracking which versions of Hare are affected by which changes.

New debugging features coming to Hare

Thu, 01 Feb 2024 00:00:00 +0000

We just merged a series of patches for Hare that adds a number of nice features for debugging Hare programs. I want to introduce these features to you, and share a bit about what’s going on that makes them possible. Let’s look at some kinds of problems which invoke these new debugging features.

Let’s start with a simple case: your program has an assertion failure. You get a pretty backtrace now:¹

Happy fourth birthday, Hare!

Wed, 27 Dec 2023 00:00:00 +0000

Happy birthday, Hare! Today is December 27th, 2023 – four years after the initial commit of the original Hare prototype repository. Let’s take this opportunity to celebrate Hare’s birthday and look over some ancient history together, in particular the early prototype implementation of Hare and all of its good old early installment weirdness.

commit d8941a4d35d109030250f8f017d771df5ad69a66
Author: Drew DeVault <sir@cmpwn.com>
Date:   Fri Dec 27 14:07:08 2019 -0700

    Initial commit

This commit from the old git repository introduced a few early pieces of Hare, not all of which survive to this day. It included:

Porting Hare to OpenBSD

Fri, 01 Dec 2023 00:00:00 +0000

OpenBSD support is the first new platform added to Hare since it was made available to the public in April 2022, initially supporting Linux and FreeBSD. Hare contributor Pasta writes for the Hare blog today about how the port was done.

I was always very interested in OpenBSD and a few months ago, I decided to give it a try. I’ve quickly fallen in love with it! There is, however, a big problem: Hare does not fully support OpenBSD! So, I decided to port it and I am happy to announce that my work was merged yesterday and OpenBSD is now fully supported by Hare. Let me show you some of the tricky stuff that was involved in the port.

Hare aims to become a 100-year programming language

Wed, 08 Nov 2023 00:00:00 +0000

There are a number of languages attempting something similar to what Hare is doing by positioning itself as an alternative to C. However, there is an important trait which I think is necessary to understand Hare’s ambitions in this space: Hare is explicitly attempting to emulate C’s 50+ year staying power. One of Hare’s explicit design goals is to produce a programming language which will be stable over a very long period of time, exceeding the lifetime of its authors: I think of Hare as a 100-year programming language.

Scaling the Hare community

Mon, 28 Aug 2023 00:00:00 +0000

I started the Hare project on December 27th, 2019, with a small commit introducing a lexer and a yacc parser for prototyping the grammar. In the nearly four years since then, a community of over one hundred contributors has grown around the project, including some eight co-maintainers working together to incorporate dozens of patches every week.

Over the past several weeks, I have been working with the other maintainers and project leaders to discuss possible reforms to the community structure and workflow to reduce bottlenecks and streamline the work, to reduce frustration with slow patch approval and make it easier for people to work autonomously — and to reduce the, uh, “Drew bottleneck”.

All rabbits welcome

Mon, 03 Jul 2023 00:00:00 +0000

We are the maintainers of the Hare programming language, and we support the right of all people to self-expression, and are building a community in which all forms of self-expression and identity are welcome, with the exception of expressions of hate and intolerance.

The Hare community values its professional tone, in which all members are treated with respect and tolerance as we work towards our shared goals. We celebrate each other and the role we each play in making this community welcoming and successful, and the value each of our personal identities brings to the project and each other. We also provide a safe space in which each individual’s challenges in participating in our community can be heard, and addressed, to ensure that participants of all backgrounds and experiences are welcome here.

Hare is a boring programming language

Sun, 27 Nov 2022 00:00:00 +0000

Hare is a boring programming language. It has relatively few features, exhaustively detailed in a short 67-page language specification. There are no macros, generics, or metaprogramming features. You just write the code and it does what you said to. Hare aims to never surprise you.

Many new systems programming languages are exploring big ideas and novel tools. Zig has comptime, Rust has procedural macros, and so on — but Hare lacks any grand ideas. Our biggest idea is ad-hoc tagged unions, which is not particularly interesting or innovative.

Making Hare more debuggable

Fri, 04 Nov 2022 00:00:00 +0000

Hare programs need to be easier to debug. This blog post outlines our plans for improving the situation. For a start, we’d like to implement the following features:

Detailed backtraces
Address sanitization
New memory allocator
DWARF support

These are roughly ordered by complexity — let’s take a look at each one in detail.

Detailed backtraces

Hare programs are always compiled with frame pointers. On x86_64, this involves generating the following entry point for each function:

Cross-compiling Hare programs is easy

Tue, 06 Sep 2022 00:00:00 +0000

Cross-compiling in Hare couldn’t be easier:

$ uname -m
x86_64
$ hare build -o main -t riscv64 main.ha
$ file main
main: ELF 64-bit LSB executable, UCB RISC-V, double-float ABI, version 1 (SYSV), statically linked, with debug_info, not stripped
$ qemu-riscv64 ./main
Hello world!

That’s it! As a bonus, since Hare programs are statically linked, you don’t even need to set up a sysroot to run this program in an emulator like qemu-riscv64.

powerctl: A small case study in Hare for systems programming

Sun, 28 Aug 2022 00:00:00 +0000

This post is mirrored from Drew DeVault’s blog

powerctl is a little weekend project I put together to provide a simple tool for managing power states on Linux. I had previously put my laptop into suspend with a basic “echo mem | doas tee /sys/power/state”, but this leaves a lot to be desired. I have to use doas to become root, and it’s annoying to enter my password — not to mention difficult to use in a script or to attach to a key binding. powerctl is the solution: a small 500-line Hare program which provides comprehensive support for managing power states on Linux for non-privileged users.

Martian time in Hare

Mon, 01 Aug 2022 00:00:00 +0000

This is a republication from Byron Torres’s blog.

Preface

Development of the Hare programming langauge is chugging along. From what I’ve gathered from IRC, Drew Devault has been spending most of his hare-dev time on Helios, in an effort to throw real code at Hare and scrutinize its design choices. For example, since then, a @threadlocal keyword has come into consideration.

My focus area is naturally the datetime and time::chrono modules of the standard library, both of which I primarily wrote, and which I maintain and intend to for a long time. These modules too have been made with unique design choices.

Safety features of the Hare programming language

Tue, 21 Jun 2022 00:00:00 +0000

Hare offers many important advances over its main inspiration, C, when it comes to safety features. These features prevent the programmer from making mistakes, ideally without preventing them from doing what they want to do. Some of these features reduce the risk of classic security problems, such as buffer overflows, but they are generally designed with the broader hope of reducing the risk of your program having bugs of any kind. After all, any bug can become a security vulnerability under the right conditions.

Implementing regular expressions in Hare

Fri, 03 Jun 2022 00:00:00 +0000

Regular expressions are one of those tools that we kind of take for granted. They’re really powerful and useful in so many situations, but most people don’t quite understand how they work under the hood. I’m Vlad, the developer who implemented Hare’s regular expression engine, and I thought I’d show you why regular expressions aren’t as scary as they might seem at first sight. In this post, I’d like to take a look at how Hare’s implementation works, as well as how an end-user would go about using it. Let’s get started.

A Hare code generator for finding ioctl numbers

Sat, 14 May 2022 00:00:00 +0000

Modern Unix derivatives have this really bad idea called ioctl. It’s a function which performs arbitrary operations on a file descriptor. It is essentially the kitchen sink of modern Unix derivatives, particularly Linux, in which they act almost like a second set of extra syscalls. For example, to get the size of the terminal window, you use an ioctl specific to TTY file descriptors:

let wsz = rt::winsize { ... };
match (rt::ioctl(fd, rt::TIOCGWINSZ, &wsz: *void)) {
case let e: rt::errno =>
	switch (e: int) {
	case rt::EBADFD =>
		return errors::invalid;
	case rt::ENOTTY =>
		return errors::unsupported;
	case =>
		abort("Unexpected error from ioctl");
	};
case int =>
	return ttysize {
		rows = wsz.ws_row,
		columns = wsz.ws_col,
	};
};

This code performs the ioctl syscall against the provided file descriptor “fd”, using the “TIOCGWINSZ” operation, and setting the parameter to a pointer to a winsize structure. There are thousands of ioctls provided by Linux, and each of them is assigned a constant like TIOCGWINSZ (0x5413). Some constants, including this one, are assigned somewhat arbitrarily. However, some are assigned with some degree of structure.

Implementing an SSH agent in Hare

Mon, 09 May 2022 00:00:00 +0000

In the process of writing an SSH agent for Himitsu, I needed to implement many SSH primitives from the ground up in Hare, now available via hare-ssh. Today, I’m going to show you how it works!

Important: This blog post deals with cryptography-related code. The code you’re going to see today is incomplete, unaudited, and largely hasn’t even seen any code review. Let me begin with a quote from the “crypto” module’s documentation in the Hare standard library:

Will Hare replace C? Or Rust? Or Zig? Or anything else?

Mon, 02 May 2022 00:00:00 +0000

Nope.

If the short answer leaves you wanting, keep reading. I must admit that this sentence from the Hare announcement may have caused some confusion:

Hare is most similar to C, and almost all programs written in C can also be written in Hare.

This is especially true in the context of the rising and competing compliment of “C replacement” languages, of which some are explicit about their goals to replace C, such as Rust. There is a movement to rewrite existing C code in Rust and by such means take over the world, mwahahaha. Hare is not interested in taking over the world, and I do not recommend that programmers start rewriting their C programs in Hare.

Announcing the Hare programming language

Mon, 25 Apr 2022 00:00:00 +0000

Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.

Here is my favorite example program, which computes its own SHA-256 hash:

use crypto::sha256;
use encoding::hex;
use fmt;
use hash;
use io;
use os;

export fn main() void = {
	const hash = sha256::sha256();
	const file = os::open("main.ha")!;
	defer io::close(file)!;
	io::copy(&hash, file)!;

	let sum: [sha256::SIZE]u8 = [0...];
	hash::sum(&hash, sum);
	hex::encode(os::stdout, sum)!;
	fmt::println()!;
};

We have been developing Hare in private for about two and a half years, and have decided that it’s now time to offer it to you to play with. Hare is a reasonably (though not entirely) complete programming language that you can pick up today and start writing interesting and useful systems software with. If you’d like to try it out, check out the installation procedure, then the Hare tutorial.

Chronology in Hare

Sun, 17 Apr 2022 00:00:00 +0000

Date and time support has come to Hare, with the introduction of two new modules to the standard library, written by Hare contributors Byron Torres (Hi, there! Today’s blog guest) and Vlad-Stefan Harbuz.

With these, we are now able to handle human notions of time: dates, the Gregorian calendar, wall-times, timezones, the “Olson” Timezone database, timezone transitions (daylight saving time, etc.), and timescales (leap seconds, etc.). We can also parse, format, and programmatically construct datetimes of high precision, and perform elementary calendrical arithmetic.

Implementing a MIME database in Hare

Fri, 28 Jan 2022 00:00:00 +0000

Recently, I have been working on implementing a parser for media types (commonly called MIME types) and a database which maps media types to file extensions and vice-versa. I thought this would be an interesting module to blog about, given that it’s only about 250 lines of code, does something useful and interesting, and demonstrates a few interesting Hare concepts.

The format for media types is more-or-less defined by RFC 2045, specifically section 5.1. The specification is not great. The grammar shown here is copied and pasted from parts of larger grammars in older RFCs, RFCs which are equally poorly defined. For example, the quoted-string nonterminal is never defined here, but instead comes from RFC 822, which defines it but also states that it can be “folded”, which technically makes the following a valid Media Type:

Using "hare release" to ship Hare software

Mon, 22 Nov 2021 00:00:00 +0000

The “hare” command now includes a new sub-command, “hare release”, which can be used to manage releases for software written in Hare. This tool checks for common mistakes and establishes common packaging standards for use throughout the Hare ecosystem, making releases easy, consistent, and difficult to screw up. Let me explain how it works, and how to use it for your own releases.

Note: We’ve now gotten rid of hare release. This blog post is still here for historical purposes, but it no longer reflects the current state of Hare.

How reflection works in Hare

Tue, 05 Oct 2021 00:00:00 +0000

I’ve just merged support for reflection to Hare. Here’s how it works!

Note: This feature didn’t make the cut, we rolled it back a few months later. Neat to see how it might have worked, though!

Background

“Reflection” refers to the ability for a program to examine the type system of its programming language, and to dynamically manipulate types and their values at runtime. You can learn more at Wikipedia.

Reflection from a user perspective

Let’s start with a small sample program:

Strategies for handling OOMs in Hare programs

Wed, 28 Apr 2021 00:00:00 +0000

For most programs, an OOM (out-of-memory) scenario is unlikely, and handling them is annoying. For this reason, the “default” expectation for Hare programs is that they will abort when the system runs out of memory. Your memory usage is still your responsibility — and we provide tools for understanding it (to be described in a future post) — but the typical program doesn’t need to worry about running out.

However, Hare is a systems programming language, and some systems do care. One example of such a situation is a kernel: it’s never acceptable to simply crash the kernel if you run out of memory. So how does someone working in one of these memory-critical domains use Hare effectively?

Future research areas

Tue, 30 Mar 2021 00:00:00 +0000

Right now, development is focused on refining our basic language design, populating the standard library, and writing a hosted compiler. However, there are a three research areas planned for the future which may cause major changes to the language, prior to its public release. These research areas are set aside for us to evaluate how they fit (or don’t) into the language design, come up with working prototypes, and incorporate them into Hare before it’s public, so that we can address these issues without making any major breaking changes after programs in the wild start to depend on Hare.

High-level data structures in Hare

Fri, 26 Mar 2021 00:00:00 +0000

Hare does not support generics, and our approach to data structures is much like C: DIY. Hare supports the following basic data structures:

Arrays
Slices
Tuples
Structs and unions
Tagged unions

That’s the complete list of aggregate type classes defined by the specification. You can build arbitrarily complex data structures out of these, but, like C, Hare puts the ball in your court. For most of your application’s day-to-day data processing needs, these types are sufficient, shunting data from A to B without much fuss. For most of your data processing, these limitations will not be your bottleneck, and simpler (but slower) data structures won’t have much of an impact on your program.

Hare standard library development

Fri, 19 Mar 2021 00:00:00 +0000

I’m happy to see more contributors getting on board with standard library development! The standard library is extremely important to Hare’s success, and building it is a lot of work, which means we need a lot of help to get it done. This article should serve as an introduction to the standard library development process for new contributors. As a pre-requisite, please complete the Installation procedure and the Hare language introduction.

The standard library lives in the main Hare source tree, and tickets for it are marked with the “stdlib” label on the bug tracker (if you need access to this, ask on IRC). I also recommend reading the standard library mandate, which establishes the scope and goals.

Hare's path to a self-hosting toolchain

Sun, 14 Mar 2021 00:00:00 +0000

Last night I applied Ember Sawady’s latest patch, implementing forward references for the bootstrap compiler. With this completed, the hosted build driver is operational. Compiling a Hare program is now one hare build command away, rather than a complex series of hacks to patch together a working toolchain on the fly. Said hacks are still in place — for bootstrapping the language from scratch — but are not necessary for the daily workflow of using Hare to write useful programs.

Hare's advances compared to C

Tue, 09 Feb 2021 00:00:00 +0000

The Hare programming language makes a number of improvements compared to the language from which it draws much of its inspiration. Like C, Hare has a very small runtime, manual memory access, direct access to pointers, and dangerous features which you are free to point at your feet and shoot, albeit only after signing a waiver.

Despite the veneration with which we look upon C, those who look upon it with scorn do have some valid concerns. A complete lack of memory-safe features and a miserable error handling experience both make it pretty easy to make mistakes in C that are not possible elsewhere. Some of this also makes it possible to do desirable things which are not possible in those other languages, but it would be nice to have options for when you don’t need to do those things and just want to write reliable code.