Hew
A language built for what comes next.
Actor isolation, supervision trees, and wire contracts — compiled to native code through LLVM.
actor ChatRoom {
users: Vec<String>,
receive fn join(name: String) {
self.users.push(name)
}
}Active development · Rust-powered compiler · LLVM & C backends Learn more →
Built different
Four language-level guarantees that libraries can't provide.
Actor Isolation
Every actor owns its state. No shared memory, no data races. Compile-time capability checking ensures safety without runtime cost.
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. No orphan goroutines, no leaked futures.
Wire Contracts
Network protocols are first-class types. Schema evolution rules enforced at compile time. No reflection, no runtime surprises.
Actors and supervisors
in the language itself
Not a framework. Not a library pattern. Actors are declared with actor, supervisors with supervisor. The compiler enforces isolation, message-passing boundaries, and restart semantics.
When a Session actor crashes, its supervisor restarts it automatically — with bounded retries and time windows, preventing cascade failures.
actor Session { user: String, messages: Vec<String>, receive fn post(text: String) { self.messages.push(text) } receive fn history() -> Vec<String> { self.messages }}supervisor SessionPool { strategy: one_for_one, max_restarts: 5, window: 60, children: [Session]}Coming from...
What Hew gives you that your current language doesn't.
Goroutine leaks, shared state races
Scoped tasks, isolated actors — by design
No built-in actor model or supervision
Actors and supervisors are language primitives
Dynamic types, runtime errors
Static types, compile-time safety, native speed
Start building with Hew
Install the compiler and write your first actor in minutes.