Hew

Un langage qui anticipe les défaillances.

Reprise après panne, isolation par acteurs, et protocoles sûrs — intégrés au langage et vérifiés par le compilateur.

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 →

Basé sur les acteurs Sûr à la compilation Natif via LLVM Tolérant aux pannes Natif pour les réseaux

Install Hew

Get up and running in seconds.

Garanties du langage

Des décisions prises au niveau du langage, cohérentes dans chaque projet.

Isolation par acteurs

Chaque acteur possède son état de façon exclusive. Le compilateur vérifie les frontières d'isolation à la compilation : la sûreté est garantie avant l'exécution.

Arbres de supervision

Les services tombent — Hew l'anticipe. Les acteurs superviseurs relancent les enfants défaillants avec des stratégies configurables : un-pour-un, tous-pour-un, reste-pour-un.

Concurrence structurée

Les tâches sont liées à leur parent. Quand un acteur s'arrête, ses tâches s'arrêtent. Le nettoyage est automatique et déterministe.

Contrats réseau

Les protocoles réseau sont des types de première classe. Les règles d'évolution de schéma sont appliquées à la compilation. La compatibilité est garantie avant le déploiement.

Acteurs et superviseurs comme constructions du langage

Déclarez des acteurs avec actor, des superviseurs avec supervisor. Le compilateur impose l'isolation, les frontières de passage de messages et la sémantique de redémarrage — des idées d'Erlang/OTP, avec des types statiques et la vitesse native.

Quand un acteur Session tombe en panne, son superviseur le redémarre automatiquement — avec des tentatives limitées et des fenêtres temporelles qui confinent les défaillances.

Lire la visite du langage →
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);
}

Sur les épaules des géants

Ce que trois langages ont prouvé, Hew les réunit.

Go

Les goroutines et les canaux ont montré que la concurrence appartient au langage.

Hew y apporte la structure — des tâches délimitées et des acteurs isolés rendent le code concurrent prévisible.

Rust

La propriété a prouvé que les garanties à la compilation peuvent rendre certaines catégories d'erreurs impossibles.

Hew applique cette rigueur à la concurrence — acteurs et superviseurs vérifiés par le compilateur.

Erlang

OTP a prouvé que la tolérance aux pannes est une architecture — intégrée dès le départ.

Hew porte le principe let-it-crash avec des types statiques et une compilation native.

Journal de développement

35 billets documentant la construction de Hew — du premier analyseur syntaxique aux acteurs distribués.

Lire le blogue

Écrivez votre premier acteur supervisé

Installez le compilateur et lancez un service tolérant aux pannes en quelques minutes.

Démarrer Toutes les fonctionnalités