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, , ,

Revendications de production

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

• la surface de langage sécurisé livrée est sûre pour la mémoire par défaut dans le cadre des règles documentées du vérificateur/compilateur, avec des limites non sécurisées auditées explicites et une gestion manuelle de la mémoire optionnelle avec suivi de possession
• la sémantique interne du compilateur/exécution/outils reste une source de vérité typée, JSON étant réservé aux limites externes, aux artefacts générés et à la sortie machine destinée aux opérateurs
• alloc(...) / free(...) restent dans le code sûr lorsque le compilateur peut encore vérifier la possession, la provenance et l'exécution du nettoyage
• correction vérifiable via le vérificateur, les diagnostics, les tests déterministes, le rejeu et les artefacts CI
• exécution déterministe via des traces enregistrées, le rejeu et le contrôle de l'ordonnanceur
• couverture générale des systèmes sur asynchrone/tâches, RPC, ADT, traits/génériques, contrôle de processus, E/S terminal, journalisation, système de fichiers/chemin, état interne typé, JSON aux limites et HTTP en streaming
• couverture web/service de production via fzweb plus des primitives de sécurité qui maintiennent les flux session/cookie/auth dans la surface d'exécution prise en charge

Voir aussi :

• docs/system-safety-trust-model-v1.md
• docs/production-memory-model-v1.md
• docs/production-workflow-v1.md

Construire et tester

cargo check --workspace
cargo test --workspace

CLI principale

# Scaffold a project in the current directory or a target path
fz init [path] [--name package] [--template minimal|rust|ts] [--with run,fuzz,explore,memory,host|all] [--force]

# Build source/project
fz build [path] [--release] [--lib] [--threads N] [--backend llvm|cranelift] [--pgo-generate|--pgo-use file] [-l lib] [-L path] [-framework name] [--json]

# Run source/project or .fozzy scenario
fz run [path] [--det] [--strict-verify] [--seed N] [--record path] [--host-backends] [--backend llvm|cranelift] [--max-seconds N] [--exit-on-healthcheck URL] [--smoke-http URL] [-- <args>] [--json]

# Test source/project or .fozzy scenario
fz test [path] [--det] [--strict-verify] [--sched fifo|random|coverage_guided] [--seed N] [--record path] [--backend llvm|cranelift] [--filter substring] [--json]

# Verify/check/docs/tooling
fz fmt [path ...] [--check] [--json]
fz check [path] [--json]
fz verify [path] [--json]
fz lint [path] [--tier production|pedantic|compat] [--json]
fz dx-check [project] [--strict] [--json]
fz spec-check [--json]
fz emit-ir [path] [--json]
fz perf [--artifact artifacts/bench_core_rust_vs_fzy.json] [--json]
fz stability-dashboard [--json]
fz parity [path] [--seed N] [--json]
fz audit unsafe [path] [--workspace] [--json]
fz vendor [project] [--json]
fz abi-check <current.abi.json> --baseline <baseline.abi.json> [--json]
fz debug-check [path] [--json]
fz pgo merge [path] [--out file] [--json]
fz lsp diagnostics [path] [--json]
fz lsp definition <path> <symbol> [--json]
fz lsp hover <path> <symbol> [--json]
fz lsp rename <path> <from> <to> [--json]
fz lsp smoke [path] [--json]
fz lsp serve [--path <workspace>] [--json]
fz map suites [--root dir] [--scenario-root dir] [--profile pedantic|production|compat] [--json]
fz artifacts ls latest [--json]
fz report show latest [--format json|text] [--json]
fz usage [--json]
fz env [--json]
fz version [--json]
fz inspect stdlib <module> [--json]
fz schema [--json]
fz validate <scenario> [--json]
fz trace verify <trace> [--strict] [--json]
fz replay <trace> [--json]
fz shrink <trace> [--json]
fz ci <trace> [--json]
fz trace-native <trace.fozzy> [--out path] [--json]

# FFI / RPC / docs outputs
fz headers [path] [--out path] [--json]
fz rpc gen [path] [--out-dir dir] [--json]
fz doc gen [path] [--format json|html|markdown] [--out path] [--reference path] [--json]

L'intégration VS Code se trouve dans tooling/vscode et cible fz lsp serve.

Valeurs par défaut d'exécution et comportement exposé :

• hôte de liaison par défaut : 127.0.0.1
• port par défaut : 8787
• la cible de liaison effective est affichée lors d'un listen réussi
• .env ou FZ_DOTENV_PATH est chargé une fois avant les opérations env/HTTP
• les logs textuels sont la valeur par défaut ; les logs JSON sont optionnels via log.set_json(1)
• la surface de la bibliothèque standard inclut core.process, core.term, core.thread, core.log, core.text, core.io, core.path, et core.util

Artefacts déterministes

Avec fz test <file.fzy> --det --record artifacts/name.trace.json --json, le pilote émet :

• *.trace.json : trace d'exécution déterministe
• *.timeline.json : décisions d'ordonnancement
• *.report.json : résumé, résultats et regroupement des échecs
• *.explore.json : candidats d'ordonnancement et priorités de scénario
• *.shrink.json : indices de réduction déterministe
• *.scenarios/ et *.scenarios.json : scénarios natifs du langage générés
• *.manifest.json : carte des artefacts incluant le chemin du scénario principal

Surface CLI native

Répartition de la rédaction canonique :

• core.process, core.term, core.text : argv et UX terminal
• core.log : politique de journalisation et sortie structurée
• core.io, core.path : découverte du système de fichiers et assemblage de chemins
• proc.* : exécution de processus enfants

Exemple :

use core.log;
use core.process;
use core.term;
use core.text;

fn main() -> i32 {
    let mode = process.argv_or(1, "serve")
    discard log.set_sink_name("stderr")
    discard log.set_level_name("warn")
    discard term.transcript_kv("mode", mode, 8)
    if term.is_interactive() == 1 {
        discard term.eprint_line(str.concat("interactive=", str.from_i32(term.is_interactive())))
    }
    discard term.print_line(text.indent("ready\nwaiting", "  "))
    return 0
}

EOF est explicite :

• ligne vide : term.read_line() == "" et term.stdin_eof() == 0
• EOF : term.read_line() == "" et term.stdin_eof() == 1

Pour un travail sérieux en CLI/exécution, utilisez à la fois le lanceur intégré au compilateur et le binaire construit lorsque le comportement exact du terminal est important.

Politique du backend natif

• backends pris en charge : cranelift et llvm
• ordre de sélection : --backend explicite, puis FZ_NATIVE_BACKEND, puis la valeur par défaut du profil
• valeurs par défaut du profil : dev -> cranelift, release -> llvm

Verrouillage des dépendances + Vendeur

• les constructions de projet imposent les vérifications de dérive fozzy.lock pour les dépendances de chemin
• actualisez l'état du verrouillage avec fz vendor [project] --json
• la sortie du vendeur inclut fozzy.lock et vendor/fozzy-vendor.json
• spécification : docs/dependency-locking-v1.md

Porte de compatibilité ABI

fz abi-check impose :

• validité du schéma
• identité du paquet
• compatibilité de la limite de panique
• présence des exportations de base et immutabilité de la signature
• immutabilité du contrat de base
• non-régression de la version du symbole

Les exportations additives sont autorisées.

Interopérabilité C

• guide : docs/c-interop-production-v1.md
• chaque pubext c fn exportée nécessite #[ffi_panic(abort|error)]
• préférez ext unsafe c fn pour les imports C non sécurisés et appelez-les uniquement à l'intérieur de unsafe { ... }
• fz build --lib émet des bibliothèques statiques/partagées plus un en-tête installable et un manifeste ABI
  • le contrat backend actuel est Cranelift uniquement pour les constructions de bibliothèque ; un --backend llvm explicite est rejeté avec un indice de migration

Artefacts de documentation non sécurisée

• unsafe est de première classe via unsafe fn et unsafe { ... }
• fz audit unsafe --workspace --json émet .fz/unsafe-map.workspace.json, .fz/unsafe-docs.workspace.json, .fz/unsafe-docs.workspace.md, et .fz/unsafe-docs.workspace.html
• les champs de métadonnées tels que reason, invariant, owner, scope, risk_class, et proof_ref sont générés par le compilateur et pilotés par la politique
• le flux de production par défaut n'est pas bloquant pour les métadonnées manquantes, sauf si la politique stricte non sécurisée est activée

Contrat de validation déterministe

Utilisez cette séquence pour une confiance stricte :

# 1) Audit de déterminisme d'abord
fz doctor --deep --scenario tests/run.pass.fozzy.json --runs 5 --seed 42 --json

# 2) Tests déterministes stricts
fz test --det --strict-verify tests/run.pass.fozzy.json tests/memory.pass.fozzy.json --json

# 3) Enregistrer une trace réelle
fz run tests/run.pass.fozzy.json --det --record artifacts/trace.fozzy --json

# 4) Valider le pipeline de rejeu
fz trace verify artifacts/trace.fozzy --strict --json
fz replay artifacts/trace.fozzy --json
fz ci artifacts/trace.fozzy --json

# 5) Passage de confiance hébergé
fz run tests/host.pass.fozzy.json --host-backends --json

Porte de libération stricte :

./scripts/ship_release_gate.sh

Cela inclut des vérifications d'intégrité des revendications de documentation bloquant la publication via scripts/safety_claim_integrity_gate.py.

Exemple : Cycle de vie des tests natifs

cat >/tmp/demo.fzy <<'FZY'
test "alpha" {}
test "beta" nondet {}
rpc Ping(req: PingReq) -> PingRes;
async fn worker() -> i32 {}
fn main() -> i32 {
    timeout(1)
    return 0
}
FZY

fz test /tmp/demo.fzy --det --sched random --seed 13 --record artifacts/demo.trace.json --json

Inspectez directement les artefacts de test natifs émis :

• artifacts/demo.trace.native.trace.json
• artifacts/demo.trace.report.json
• artifacts/demo.trace.timeline.json lorsque les artefacts riches sont activés
• artifacts/demo.trace.manifest.json

Les manifestes de test natifs sont des entrées de première classe trace verify / replay / ci pour les exécutions de test natif enregistrées. Ce ne sont pas des entrées de scénario et ne participent pas à la shrink de scénario.

Exemples de projets

Tous les exemples fournis suivent la convention narrative v1 DX :

• src/main.fzy est uniquement dédié à l'orchestration et place fn main en dernier
• les tests se trouvent sous src/tests/*
• les racines des modules de domaine utilisent mod.fzy

Projets disponibles :

• examples/agent_runtime
• examples/context_runtime
• examples/minimal_runtime
• examples/service_app
• examples/fullstack
• examples/robust_cli
• examples/live_server

Validation et flux de projet :

fz dx-check examples/fullstack --strict --json

fz check examples/fullstack --json
fz build examples/fullstack --backend cranelift --json
fz build examples/fullstack --release --backend llvm --json
fz run examples/fullstack --backend cranelift --json
fz test examples/fullstack --det --seed 41 --backend llvm --json
fz headers examples/fullstack --json
fz abi-check examples/fullstack/include/fullstack.abi.json --baseline examples/fullstack/include/fullstack.abi.json --json

fz dx-check examples/robust_cli --strict --json
fz build examples/robust_cli --backend cranelift --json
fz run examples/robust_cli --backend llvm --json
fz test examples/robust_cli --det --seed 55 --backend cranelift --json

fz dx-check examples/live_server --strict --json
fz build examples/live_server --backend cranelift --json
fz run examples/live_server --backend llvm --json
fz test examples/live_server --det --seed 77 --backend cranelift --record artifacts/live_server.stats.trace.json --rich-artifacts --json

fz run tests/live.server.interhttp.fozzy.json --host-backends --json

Si vous contribuez à partir d'un checkout plutôt que d'installer une version publiée, utilisez cargo run -q -p fz -- <args> comme solution de secueil depuis les sources.

Suivi du plan

Tenez ces documents de livraison versionnés à jour pendant l'implémentation :

• PLAN.md
• FEATURES-TO-SHIP.md