I'd like to share Hale, a concurrent systems language that I've been working on this year.

The general thesis is that good software design is an actual thing. In everything I've ever programmed or designed, in any part of the stack, I've always felt like the design "to be implemented" is always the same, but given the actual intersect of language, libraries and domain, the way the implementation looks and comes together feels different. We know that software designs are good or bad, and we talk amongst ourselves about design patterns and whatnot, when we try to actually describe what the good design is. Generally speaking, it's not uncommon for large codebases to define some baseline process harness that codifies a few technical opinions for the rest of the project. Choices here shape what the "good design" must be for the rest of the program, given the harness/framework's foundation. Since the clankers started doing uppers at the end of last year, I feel like most of my time with agentic coding has been spent speed running corrections to the good design. The surface area of languages and libraries are so granular these days, the space of decision making at any point in a project is pretty large.

The abstract act of driving an agent session is manually course correcting, keeping the intersect of requirement, specification, and machine instruction aligned. The boundary conditions in that statement - the requirements and the instructions that a machine can handle - are effectively static. Only the middle layer, the specification, is fungible, from the SDLC perspective. Hale codifies a recursive hypergraph model, which enables expressing an application's specification using the same stacked singular shape. We can program our units of code using both direct ownership and async messaging. Hale offers pure logical isolation for the domain implementation and the technical deployment. The structure of Hale maps directly to the machine hardware layout, so no-gc no lifetime management are just, free: the structure of the language results in deterministic ownership and frees at compile time.

I've been using Hale to replace a fleet of apps that I've been maintaining in Go. The language is stable enough that I feel like others could start using it without it being a waste of time, so I'd be super interested in any feedback anyone has here.

LLM usage disclosure: I use Claude to write code. I used to use vim. The language design has lived in my head for a long time, and I only use Claude via a single session with myself actually reviewing code and decision making. I don't do like, swarming or whatever.