Hew
A language built for what comes next.
High-performance. Network-native. Machine-code compiled. Hew combines actor isolation, supervision trees, structured concurrency, and wire contracts into a language designed for long-lived services.
Four Pillars
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. Built-in 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. Cooperative cancellation by default.
Wire Contracts
Network protocols are first-class types. Schema evolution rules are enforced at compile time. Wire types serialize directly — no reflection, no runtime surprises.
See it in action
Actors, supervisors, and functions — all in one language.
actor Counter {
count: i32,
receive fn increment(amount: i32) -> i32 {
self.count = self.count + amount
self.count
}
receive fn get_count(unused: i32) -> i32 {
self.count
}
}
supervisor CounterPool {
strategy: one_for_one,
max_restarts: 5,
window: 60,
children: [Counter]
}
fn main() -> i32 {
let result = fibonacci(10);
println(result);
0
}
fn fibonacci(n: i32) -> i32 {
if n <= 1 { n }
else { fibonacci(n - 1) + fibonacci(n - 2) }
}Why Hew?
Compiles to Machine Code
No VM, no garbage collector pauses. Hew compiles through LLVM to native binaries. Fast startup, predictable latency.
Network-Native
Wire types are part of the language. Define your protocol once, get serialization, versioning, and compatibility checking for free.
Built for Services
Actors, supervisors, backpressure, and cancellation are language features, not library choices. Your architecture is in your type system.