fzy (fozzylang)

Langage systèmes à usage général et chaîne d'outils de production avec une surface de langage sécurisé livrée par défaut, une correction vérifiable, une exécution déterministe et un débogage basé sur le rejeu intégré.

fzy livre une CLI de production, fz, pour les workflows du compilateur et la validation déterministe. La correction, le déterminisme, le rejeu, les artefacts d'incident et les preuves de production font partie du workflow normal plutôt que d'une réflexion ultérieure. Pour un aperçu visuel rapide du langage, ouvrez la vitrine FZL fournie dans votre navigateur avec open fzl-showcase.html. Pour l'argumentation concise expliquant pourquoi vous pourriez le choisir, consultez WHYFZY.md.

La politique d'architecture du référentiel est typée en interne et JSON uniquement aux limites réelles.

Commencer ici

• Installation : INSTALL.md
• Manuel complet : USAGE.md
• Pourquoi fzy : WHYFZY.md
• Syntaxe et exemples de commandes : CODE.md
• Workflow de production : docs/production-workflow-v1.md
• Programmation et validation GPU : docs/gpu-v1.md
• Modèle de sécurité et de confiance : docs/system-safety-trust-model-v1.md
• Rédaction non sécurisée : docs/unsafe-contract-authoring-v1.md
• Niveaux de stabilité : docs/language-stability-v1.md
• Héritage des politiques d'espace de travail : docs/workspace-policy-v1.md
• Informations opérationnelles : docs/operational-insights-v1.md
• fzyllm : saint0x/fzyllm

Installer

Installation recommandée :

curl -fsSL https://raw.githubusercontent.com/saint0x/fzy/main/install.sh | sh

Cela installe fz dans ~/.local/bin, met à jour PATH si nécessaire, et vérifie l'installation avec fz version et fz env.

Solution de secours depuis les sources :

curl -fsSL https://raw.githubusercontent.com/saint0x/fzy/main/install.sh | sh -s -- --from-source

Aperçu rapide

Vous voulez l'aperçu le plus rapide ? Ouvrez fzl-showcase.html avec open fzl-showcase.html, parcourez WHYFZY.md pour l'argument produit, puis utilisez l'exemple ci-dessous comme un sketch exécutable compact.

use core.log;
use core.path;
use core.process;
use core.time;

enum Mode {
    Fast,
    Safe,
}

trait Scorer {
    fn score(endpoint: Url) -> i32;
}

struct HttpScorer {}

impl Scorer for HttpScorer {
    fn score(endpoint: Url) -> i32 {
        discard endpoint;
        return 7;
    }
}

struct Config<TEndpoint> {
    retries: i32,
    endpoint: TEndpoint,
    mode: Mode,
}

fn weight(mode: Mode) -> i32 {
    match mode {
        Mode::Fast => return 3,
        Mode::Safe => return 1,
        _ => return 1,
    }
}

async fn boost(v: i32) -> i32 {
    checkpoint()
    return v + 1
}

fn normalize<T: Scorer>(cfg: Config<Url>) -> i32 {
    return weight(cfg.mode) + T.score(cfg.endpoint)
}

async fn run_once(cfg: Config<Url>) -> i32 {
    let base = normalize<HttpScorer>(cfg)
    return await boost(base)
}

fn main() -> i32 {
    let cfg = Config { retries: 4, endpoint: url.parse("https://example.test"), mode: Mode::Fast }
    let now = time.now()
    let out_path = path.join("tmp", "score.log")
    let mode = process.argv_or(1, "showcase")
    let score = normalize<HttpScorer>(cfg)
    log.info("snippet.run", out_path)
    discard mode
    discard run_once
    if score + now > 0 then return score
    return score
}

Pour une couverture plus large du langage, utilisez CODE.md, examples/ et la vitrine FZL compatible navigateur.

Les paquets du framework suivent les règles normales des paquets : déclarez-les dans fozzy.toml sous [deps], puis importez-les dans le code source avec use fzbounds;, use fzweb;, et des noms de paquets similaires. Les vérifications directes du code source telles que fz check src/services/mod.fzy --json valident désormais via le contexte du paquet propriétaire, donc les imports de dépendances et les modules frères se comportent de la même manière que dans les vérifications de projet complet.

Ce que contient fzy

• fz : CLI du compilateur pour la construction, l'exécution, les tests, la vérification, la documentation, l'IR, le RPC, les en-têtes, les vérifications ABI, et plus encore
• Formatage intégré et génération de documentation : fz fmt, fz doc gen
• Pipeline frontal et IR : crates/parser, crates/ast, crates/hir, crates/fir
• Vérificateur et application de la sécurité : crates/verifier
• Primitives d'exécution déterministes : crates/runtime
• Pilote et orchestration d'artefacts : crates/driver
• Scénarios Fozzy exécutables : tests/*.fozzy.json

État actuel

Implémenté et validé aujourd'hui :

• Portée générale d'un langage systèmes, pas un outil spécialisé dans un seul domaine
• Sûr par défaut, avec des îlots non sécurisés explicites, un inventaire/documentation non sécurisée généré par le compilateur, et une gestion manuelle de la mémoire sur option via alloc(...) / free(...)
• Sémantique réelle defer d'exécution dans le code normal et les îlots unsafe { ... }, donc un nettoyage déterministe est imposé plutôt que simplement documenté
• Règles de possession, d'emprunt, de capacité, d'FFI et d'abaissement natif appliquées par le vérificateur
• La gestion manuelle explicite de la mémoire est prise en charge dans ce modèle, avec des flux alloc(...) / free(...) conscients de la possession et des vérifications du cycle de vie visibles par le vérificateur
• Trace déterministe, rejeu et validation de l'ordonnanceur comme des portes de production normales
• Chemins de confiance hébergés pour le système de fichiers, les processus et le comportement HTTP
• Modes d'ordonnanceur déterministes : fifo, random, coverage_guided
• Artefacts de décision pour l'exécution asynchrone, les threads et le RPC
• Événements de trame RPC : rpc_send, rpc_recv, rpc_deadline, rpc_cancel
• Métadonnées d'exploration et de réduction pour les workflows de rejeu/minimisation
• Génération de scénarios natifs du langage à partir de blocs test analysés
• Chargement récursif de modules multi-fichiers à partir de déclarations mod
• Génération d'en-têtes C à partir de signatures pubext c fn exportées
• Génération de schéma RPC, de client et de stub serveur via fz rpc gen
• Surface moderne du langage/exécution avec ADT, filtrage par motifs, traits, génériques, modélisation de domaine typée, processus, terminal, journalisation, système de fichiers/chemin, JSON aux limites, et HTTP sortant en streaming
• Surface crypto/sécurité de production via core.crypto et core.security, incluant aléatoire sécurisé, hachage, HMAC, comparaison à temps constant et encodages sûrs pour URL
• Modules du framework web de production fzweb pour le routage applicatif, cookies, sessions, téléchargements multipart, persistance, SSE, websockets et export OpenAPI
• fz run exécute directement la sortie native avec diffusion en direct du texte ou capture JSON
• Backends natifs LLVM et Cranelift avec validation orientée parité
• Portes de libération mémoire directe :
  • python3 scripts/direct_memory_architecture_gate.py
  • python3 scripts/direct_memory_perf_gate.py
• Surface GPU de production via core.gpu, avec exécution Metal en direct sur Apple plus des contrats d'adaptateur partagé spirv/nvptx

Revendications de production

fzy est configuré pour soutenir ces revendications de production aujourd'hui :