fzy (fozzylang)

Linguaggio per sistemi di uso generale e toolchain di produzione con una superficie linguistica sicura di default, correttitudine verificabile, esecuzione deterministica e debugging basato su replay integrato.

fzy fornisce una CLI di produzione, fz, sia per i flussi di lavoro del compilatore che per la validazione deterministica. Correttitudine, determinismo, replay, artefatti di incidente ed evidenze di produzione fanno parte del normale flusso di lavoro, non sono un ripensamento. Per una rapida panoramica visiva del linguaggio, apri la vetrina FZL nel tuo browser con open fzl-showcase.html. Per la breve argomentazione sul perché potresti sceglierlo, vedi WHYFZY.md.

La politica di architettura del repository è tipizzata internamente e JSON solo ai confini reali.

Inizia Qui

• Installazione: INSTALL.md
• Manuale completo: USAGE.md
• Perché fzy: WHYFZY.md
• Esempi di sintassi e comandi: CODE.md
• Flusso di lavoro di produzione: docs/production-workflow-v1.md
• Programmazione GPU e validazione: docs/gpu-v1.md
• Modello di sicurezza e fiducia: docs/system-safety-trust-model-v1.md
• Authoring non sicuro: docs/unsafe-contract-authoring-v1.md
• Livelli di stabilità: docs/language-stability-v1.md
• Ereditarietà delle policy del workspace: docs/workspace-policy-v1.md
• Approfondimenti operativi: docs/operational-insights-v1.md
• fzyllm: saint0x/fzyllm

Installa

Installazione consigliata:

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

Questo installa fz in ~/.local/bin, aggiorna PATH se necessario e verifica l'installazione con fz version e fz env.

Fallback dal sorgente:

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

Panoramica Rapida

Vuoi la panoramica più veloce? Apri fzl-showcase.html con open fzl-showcase.html, sfoglia WHYFZY.md per l'argomentazione del prodotto, poi usa l'esempio qui sotto come schizzo eseguibile compatto.

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
}

Per una copertura linguistica più ampia, usa CODE.md, examples/ e la vetrina FZL ottimizzata per browser.

I pacchetti framework seguono le normali regole dei pacchetti: dichiarali in fozzy.toml sotto [deps], poi importali nel sorgente con use fzbounds;, use fzweb; e nomi di pacchetto simili. I controlli diretti sul sorgente come fz check src/services/mod.fzy --json ora convalidano attraverso il contesto del pacchetto proprietario, quindi le importazioni delle dipendenze e i moduli fratelli si comportano allo stesso modo dei controlli sull'intero progetto.

Cosa Contiene fzy

• fz: CLI del compilatore per build, esecuzione, test, verifica, documentazione, IR, RPC, header, controlli ABI e altro
• formattazione e generazione documentazione integrate: fz fmt, fz doc gen
• pipeline front-end e IR: crates/parser, crates/ast, crates/hir, crates/fir
• verificatore e applicazione della sicurezza: crates/verifier
• primitive runtime deterministico: crates/runtime
• driver e orchestrazione artefatti: crates/driver
• scenari Fozzy eseguibili: tests/*.fozzy.json

Stato Attuale

Implementato e validato oggi:

• ambito di linguaggio per sistemi di uso generale, non uno strumento di nicchia per singolo dominio
• sicuro di default, con isole unsafe esplicite, inventario/documentazione unsafe generati dal compilatore e gestione manuale della memoria con opt-in tramite alloc(...) / free(...)
• semantica runtime reale defer sia nel codice normale che nelle isole unsafe { ... }, quindi la pulizia deterministica è imposta anziché solo documentata
• regole di proprietà, prestito, capacità, FFI e abbassabilità nativa imposte dal verificatore
• gestione manuale esplicita della memoria è supportata all'interno di quel modello, con flussi alloc(...) / free(...) consapevoli della proprietà e controlli del ciclo di vita visibili al verificatore
• traccia deterministica, replay e validazione dello scheduler come normali porte di produzione
• percorsi di fiducia basati su host per filesystem, processi e comportamento HTTP
• modalità scheduler deterministico: fifo, random, coverage_guided
• artefatti decisionali per esecuzione asincrona, thread e RPC
• eventi frame RPC: rpc_send, rpc_recv, rpc_deadline, rpc_cancel
• metadati di esplorazione e riduzione per flussi di lavoro replay/minimizzazione
• generazione nativa di scenari dal linguaggio a partire dai blocchi test analizzati
• caricamento ricorsivo di moduli multi-file dalle dichiarazioni mod
• generazione di header C dalle firme pubext c fn esportate
• generazione di schema RPC, stub client e server tramite fz rpc gen
• superficie moderna linguaggio/runtime con ADT, pattern matching, trait, generici, modellazione del dominio tipizzata, processi, terminale, logging, filesystem/path, JSON ai confini e HTTP in streaming in uscita
• superficie crittografica/di sicurezza di produzione tramite core.crypto e core.security, inclusi random sicuro, hashing, HMAC, confronto tempo costante e codifiche URL-safe
• moduli framework web di produzione fzweb per routing applicazioni, cookie, sessioni, upload multipart, persistenza, SSE, websocket ed export OpenAPI
• fz run esegue direttamente l'output nativo con streaming di testo live o cattura JSON
• backend nativi LLVM e Cranelift con validazione orientata alla parità
• porte di rilascio di memoria diretta:
  • python3 scripts/direct_memory_architecture_gate.py
  • python3 scripts/direct_memory_perf_gate.py
• superficie GPU di produzione tramite core.gpu, con esecuzione Metal live su Apple più contratti adattatore spirv/nvptx condivisi

Affermazioni di Produzione

fzy è configurato per supportare queste affermazioni di produzione oggi: