The first commit in the Hew repo landed at 1:28 AM on February 12, 2026. Not a lexer, not a parser, not a “hello world” binary — a 394-line specification document laying out what I intended to build and why. Zero implementation. Just intent.
(Whether that counts as productive is probably a matter of opinion.)
The opening paragraph hasn’t changed much since that night:
# Hew Language Specification v0.1 (Draft)
Hew is a high-performance, network-native, machine-code compiled language
for building long-lived services.That single sentence — “high-performance, network-native, machine-code compiled” — drove most of what followed. Four pillars fell out of it:
Actor isolation with compile-time data-race freedom, drawing from Pony’s reference capabilities. Each actor owns its data exclusively, no shared mutable state, and the compiler enforces the boundary instead of the programmer.
Fault tolerance via supervision trees, modeled after Erlang/OTP. Actors crash and supervisors restart them. The failure semantics live in the type system rather than getting bolted on with try/catch. (This was the hardest pillar to pin down — the first two spec drafts had contradictory crash semantics.)
Structured concurrency with cooperative cancellation, following the direction Swift took with async/await and task groups. Every concurrent task has a parent, every cancellation propagates downward — no orphaned goroutines, no leaked futures.
The fourth pillar — wire contracts with enforced schema evolution — is baked into the language rather than handled by external tooling. Services declare their message formats and the compiler checks compatibility across versions.
The v0.1 spec was ambitious and riddled with contradictions I hadn’t spotted yet. (Roughly what you’d expect from a first draft written at 1 AM.)
Tearing It Apart
A 1,076-line gap analysis followed, cataloguing twenty categories of underspecification. The module system was barely sketched — the spec had import StringLit and nothing else — and the memory management story contradicted itself in two places, one section implying reference counting while another described a tracing collector. The ownership model was gestured at but never pinned down.
Twenty categories of problems sounds alarming. I actually found it reassuring — contradictions caught on paper don’t become architectural debt buried in code. And the gap analysis doubled as a reading list, pointing directly at what needed research before writing any implementation.
Four research documents went up totaling over 1,600 lines, each surveying existing work in a domain the spec had touched.
The actor model research came first — 417 lines covering Pony, Erlang/BEAM, Akka, and Orleans. Pony’s reference capabilities prove data-race freedom at compile time without a garbage collector pause. But Pony also showed that pure actor languages struggle with adoption when the safety model is too rigid. That pushed the design toward combining strong safety guarantees with practical escape hatches.
Structured concurrency required the deepest survey — 651 lines covering Swift’s task groups, Kotlin’s coroutine scopes, Java’s Project Loom, Python’s Trio, and Go’s goroutines. (It took longer than the other three surveys combined, which probably should have told me something about how hard that part of the language was going to be.) Structured concurrency and supervision trees turned out to be complementary, not conflicting. Structured concurrency gives you scope-bounded lifetimes for tasks; supervision gives you restart policies for actors. Hew needs both.
Scheduler design (537 lines) put Go’s runtime, Tokio’s multi-threaded scheduler, and the BEAM’s preemptive reduction-counted scheduler under review. The decision landed on hybrid M:N threading with work-stealing — pin one OS thread per core, multiplex actors across them, steal work from busy queues.
Finally, the wire types survey examined Protobuf, FlatBuffers, Cap’n Proto, and MessagePack. The decision was to define a Hew-native TLV encoding rather than adopt Protobuf wholesale. Protobuf is excellent for polyglot interop, but Hew’s wire contracts are a language-level feature with compiler-enforced evolution rules — bolting that onto an external schema language would’ve created a permanent seam.
From Research Back to Spec
With the research done, the spec doubled from 394 to 927 lines. The module system got a real design. The ownership model was replaced with Pony-style reference capabilities adapted for Hew’s actor-centric semantics. Memory management contradictions resolved in favour of per-actor heaps with region-based allocation.
Once the spec felt solid enough to build against, a Rust workspace went up:
hew/
├── Cargo.toml # workspace root
├── crates/
│ ├── hewc/ # compiler driver (CLI entry point)
│ ├── hew-lexer/ # tokenizer
│ ├── hew-parser/ # parser → AST
│ ├── hew-types/ # type system, reference capabilities
│ ├── hew-ir/ # intermediate representation
│ ├── hew-codegen/ # machine code generation
│ └── hew-runtime/ # actor runtime, scheduler, supervision
└── spec/ # specification and research documentsSeven crates, each with a clear boundary and their dependency edges defined. The workspace compiled, but there was no real code yet — just the skeleton.