Hew

Eine Sprache, die mit Fehlern rechnet.

Absturzwiederherstellung, Actor-Isolation und Protokollsicherheit — in die Sprache integriert und vom Compiler geprüft.

actor ChatRoom {
  let users: Vec<string>;

  receive fn join(name: string) {
    users.push(name);
  }
}
Get Started GitHub

Active development · Rust-powered compiler · LLVM & C backends Learn more →

Actor-basiert Kompilierzeitsicher Nativ über LLVM Fehlertolerant Netzwerk-nativ

Install Hew

Get up and running in seconds.

Sprachgarantien

Entscheidungen auf Sprachebene, konsistent in jedem Projekt.

Actor-Isolation

Jeder Actor besitzt seinen Zustand exklusiv. Der Compiler überprüft Isolationsgrenzen zur Kompilierzeit — Sicherheit ist garantiert, bevor der Code ausgeführt wird.

Supervision Trees

Dienste stürzen ab — Hew rechnet damit. Supervisor-Actors starten fehlgeschlagene Kinder mit konfigurierbaren Strategien neu: one-for-one, one-for-all, rest-for-one.

Strukturierte Nebenläufigkeit

Tasks sind an ihren Eltern-Actor gebunden. Wenn ein Actor stoppt, stoppen seine Tasks. Die Bereinigung ist automatisch und deterministisch.

Wire Contracts

Netzwerkprotokolle sind erstklassige Typen. Schema-Evolutionsregeln werden zur Kompilierzeit durchgesetzt. Kompatibilität ist vor dem Deployment garantiert.

Actors und Supervisors als Sprachkonstrukte

Deklarieren Sie Actors mit actor, Supervisors mit supervisor. Der Compiler erzwingt Isolation, Nachrichtengrenzen und Neustart-Semantik — Ideen aus Erlang/OTP, mit statischen Typen und nativer Geschwindigkeit.

Wenn ein Session-Actor abstürzt, startet sein Supervisor ihn automatisch neu — mit begrenzten Wiederholungen und Zeitfenstern, die Fehler eindämmen.

Zur Sprachführung →
session.hew
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);
}

Auf den Schultern von Riesen

Was drei Sprachen bewiesen haben, vereint Hew.

Go

Goroutines und Channels haben gezeigt, dass Nebenläufigkeit in die Sprache gehört.

Hew bringt Struktur hinzu — scope-gebundene Tasks und isolierte Actors machen nebenläufigen Code vorhersagbar.

Rust

Ownership hat bewiesen, dass Kompilierzeitgarantien ganze Kategorien von Korrektheit automatisieren können.

Hew wendet diese Strenge auf Nebenläufigkeit an — Actors und Supervisors werden vom Compiler geprüft.

Erlang

OTP hat bewiesen, dass Fehlertoleranz eine Architektur ist — von Anfang an eingebaut.

Hew führt let-it-crash weiter — mit statischen Typen und nativer Kompilierung.

Entwicklungsjournal

35 Beiträge, die dokumentieren, wie Hew entsteht — vom ersten Parser bis zu verteilten Actors.

Zum Blog

Schreiben Sie Ihren ersten überwachten Actor

Installieren Sie den Compiler — in wenigen Minuten läuft Ihr fehlertoleranter Dienst.

Erste Schritte Alle Funktionen