The first useful pressure on Hew came from ordinary service code.
An actor owns some state. Another part of the program calls into it. A supervisor decides whether it restarts. A wire type crosses a process boundary and needs to keep evolving. A request handler opens resources and has to release them on every exit path.
In most languages, the important shape often lives outside the thing being checked: in naming conventions, separate schemas, shutdown callbacks, comments, or whoever wrote it last.
Hew puts more of that shape into the language.
v0.4.0 is the first release where the playground, examples, and docs form a coherent entry point into Hew.
The shape of the thing
Hew is a compiled language for actor-oriented systems. A local actor owns its state; callers interact with typed receive methods; supervisors describe restart strategy and budgets; wire types put protocol schema into the language instead of into a separate code generator.
The small counter example shows the point better than prose:
actor Counter {
var count: i64;
receive fn increment(amount: i64) -> i64 {
count = count + amount;
count
}
}
supervisor CounterPool {
strategy: one_for_one;
intensity: 5 within 60s;
child counter: Counter(count: 0) restart: permanent;
}(Update, June 2026: the snippet is revised to current v0.5 syntax — int became i64, mutable actor fields now take var, and supervisor restart policy moved to strategy: / intensity: clauses. The shape of the argument hasn’t changed.)
The interesting bit is that the actor boundary, the mutable state, and the restart policy live in the same language surface — not split across config files, schema generators, and conventions.
There is a longer set of side-by-side examples in the comparison docs. Those pages are the most useful way to see what Hew makes less fussy.
What v0.4.0 can actually do
As of v0.4.0, Hew can build and run programs through the Rust frontend and MLIR/LLVM backend. Actors, supervisors, task scopes, state machines, wire types, the browser playground, and a growing set of docs are usable.
(Update, June 2026: the MLIR layer is gone — v0.5 lowers straight from MIR to LLVM IR. Why we deleted it.)
The release itself was not mostly new syntax. It was cleanup: six breaking changes, 22 stdlib modules moved toward uniform int APIs (an effort int itself didn’t survive — v0.5 renamed it to i64), explicit teardown for resource types that had been hiding a double-free, bounded decompression, LSP improvements, and more WASM coverage. The release notes have the migration details; the design post covers the double-free and sized-integer decisions.
The remaining work is specific: distributed actors need runtime ergonomics, resource APIs are moving from explicit close / free toward proven Drop paths, and backpressure semantics need more hardening.
The status page tracks each of those edges release by release.
The website stands alone
You can run small examples in the browser. You can read the example gallery. You can install the compiler from getting started. You can compare the same patterns against Go, Rust, and Erlang in the comparison pages.
The MicroGPT port earlier this year — 120 lines of Python became 1,092 lines of Hew, and roughly a third of the file was working around compiler or stdlib gaps — was the stress test that pointed at most of the work this release closes. Most of those workarounds came out within the week; the port now sits at 677 lines.
Cleanup, and what comes next
Deterministic cleanup is the goal. v0.4.0 removed some implicit Drop registrations because explicit teardown plus a leak is easier to diagnose than a destructor that sometimes frees the same allocation twice.
The next model extends Drop coverage where the compiler can prove a single release path, and keeps explicit close / free APIs where the release path still belongs in user code.
(Update, June 2026: that model landed in v0.5 — the compiler now proves release paths for collection, record, and enum state-field overwrites and for plain-Vec locals at scope exit, and the runtime’s timer free protocol moved to a single-owner model.)