Hew
A language that expects failure.
Crash recovery, actor isolation, and protocol safety — built into the language and checked by the compiler.
actor ChatRoom {
let users: Vec<string>;
receive fn join(name: string) {
users.push(name);
}
}Active development · Rust-powered compiler · LLVM & C backends Learn more →
Install Hew
Get up and running in seconds.
$ brew install hew-lang/hew/hew$ curl -fsSL https://hew.sh/install.sh | bash$ curl -fsSL https://hew.sh/install.sh | bash> irm https://hew.sh/install.ps1 | iexLanguage guarantees
Decisions made at the language level, consistent across every project.
Actor Isolation
Every actor owns its state exclusively. The compiler verifies isolation boundaries at build time, so safety is guaranteed before your code runs.
Supervision Trees
Services crash — Hew expects it. Supervisor actors restart failed children with configurable strategies: one-for-one, one-for-all, rest-for-one.
Structured Concurrency
Tasks are scoped to their parent. When an actor stops, its tasks stop. Cleanup is automatic and deterministic.
Wire Contracts
Network protocols are first-class types. Schema evolution rules enforced at compile time. Compatibility is guaranteed before deployment.
Actors and supervisors as language constructs
Declare actors with actor, supervisors with supervisor. The compiler enforces isolation, message-passing boundaries, and restart semantics — ideas from Erlang/OTP, with static types and native speed.
When a Session actor crashes, its supervisor restarts it automatically — with bounded retries and time windows that keep failures contained.
actor Session {
let user: string;
let messages: Vec<String>;
receive fn post(text: string) {
messages.push(text);
}
receive fn history() -> Vec<String> {
messages
}
}
supervisor SessionPool {
child session: Session
restart(permanent)
budget(5, 60.seconds)
strategy(one_for_one);
}Standing on shoulders
What three languages proved, Hew combines.
Goroutines and channels showed that concurrency belongs in the language.
Hew adds structure — scoped tasks and isolated actors keep concurrent code predictable.
Ownership proved that compile-time guarantees can make entire categories of correctness automatic.
Hew applies that rigour to concurrency — actors and supervisors checked by the compiler.
OTP proved that fault tolerance is an architecture — built in from the start.
Hew carries let-it-crash forward with static types and native compilation.
Engineering Journal
35 posts documenting how Hew is built — from the first parser to distributed actors.
Write your first supervised actor
Install the compiler and have a fault-tolerant service running in minutes.