fzy (fozzylang)

Linguagem de sistemas de propósito geral e toolchain de produção com uma superfície de linguagem segura por padrão, correção verificável, execução determinística e depuração baseada em replay integrada.

O fzy fornece uma CLI de produção, fz, para fluxos de trabalho do compilador e validação determinística. Correção, determinismo, replay, artefatos de incidentes e evidências de produção fazem parte do fluxo de trabalho normal, e não uma reflexão tardia. Para um tour visual rápido da linguagem, abra o FZL showcase enviado no seu navegador com open fzl-showcase.html. Para uma breve argumentação sobre por que você pode escolhê-lo, veja WHYFZY.md.

A política de arquitetura do repositório é tipada internamente e JSON apenas em fronteiras reais.

Comece Aqui

• Instalação: INSTALL.md
• Manual completo: USAGE.md
• Por que fzy: WHYFZY.md
• Exemplos de sintaxe e comandos: CODE.md
• Fluxo de trabalho de produção: docs/production-workflow-v1.md
• Programação e validação de GPU: docs/gpu-v1.md
• Modelo de segurança e confiança: docs/system-safety-trust-model-v1.md
• Criação de módulos inseguros: docs/unsafe-contract-authoring-v1.md
• Níveis de estabilidade: docs/language-stability-v1.md
• Herança de política do workspace: docs/workspace-policy-v1.md
• Insights operacionais: docs/operational-insights-v1.md
• fzyllm: saint0x/fzyllm

Instalar

Instalação recomendada:

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

Isso instala fz em ~/.local/bin, atualiza PATH se necessário e verifica a instalação com fz version e fz env.

Alternativa a partir da fonte:

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

Visão Rápida

Quer a visão geral mais rápida? Abra fzl-showcase.html com open fzl-showcase.html, leia WHYFZY.md para o argumento do produto e depois use o exemplo abaixo como um esboço executável compacto.

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
}

Para uma cobertura mais ampla da linguagem, use CODE.md, examples/ e o FZL showcase compatível com navegadores.

Os pacotes de framework seguem as regras normais de pacotes: declare-os em fozzy.toml sob [deps], depois importe-os no código-fonte com use fzbounds;, use fzweb; e nomes de pacotes semelhantes. Verificações diretas de código-fonte, como fz check src/services/mod.fzy --json, agora validam através do contexto do pacote proprietário, para que importações de dependências e módulos irmãos se comportem da mesma forma que nas verificações de projeto completo.

O que o fzy Contém

• fz: CLI do compilador para build, run, test, verify, docs, IR, RPC, headers, verificação de ABI e muito mais
• Formatação e geração de documentação integradas: fz fmt, fz doc gen
• Pipeline front-end e IR: crates/parser, crates/ast, crates/hir, crates/fir
• Verificador e aplicação de segurança: crates/verifier
• Primitivas de runtime determinísticas: crates/runtime
• Orquestração de driver e artefatos: crates/driver
• Cenários executáveis do Fozzy: tests/*.fozzy.json

Estado Atual

Implementado e validado hoje:

• Escopo de linguagem de sistemas de propósito geral, não uma ferramenta de domínio único e nicho
• Seguro por padrão, com ilhas inseguras explícitas, inventário/documentação de insegurança gerado pelo compilador e gerenciamento manual de memória opcional via alloc(...) / free(...)
• Semântica real de defer em tempo de execução em todo código normal e ilhas unsafe { ... }, para que a limpeza determinística seja aplicada em vez de apenas documentada
• Regras de propriedade, empréstimo, capacidade, FFI e reduzibilidade nativa aplicadas pelo verificador
• Gerenciamento explícito de memória manual é suportado dentro desse modelo, com fluxos alloc(...) / free(...) cientes de propriedade e verificações de ciclo de vida visíveis pelo verificador
• Rastreamento determinístico, replay e validação do escalonador como portões de produção normais
• Caminhos de confiança com suporte do host para comportamento de sistema de arquivos, processo e HTTP
• Modos de escalonador determinísticos: fifo, random, coverage_guided
• Artefatos de decisão para execução assíncrona, threads e RPC
• Eventos de quadro RPC: rpc_send, rpc_recv, rpc_deadline, rpc_cancel
• Metadados de exploração e redução para fluxos de trabalho de replay/minimização
• Geração de cenários nativos da linguagem a partir de blocos test analisados
• Carregamento recursivo de módulos de múltiplos arquivos a partir de declarações mod
• Geração de cabeçalhos C a partir de assinaturas pubext c fn exportadas
• Geração de esquema RPC, cliente e stubs de servidor via fz rpc gen
• Superfície moderna de linguagem/runtime abrangendo ADTs, pattern matching, traits, genéricos, modelagem de domínio tipada, processo, terminal, logging, sistema de arquivos/caminho, JSON de fronteira e HTTP de streaming de saída
• Superfície de criptografia/segurança de produção via core.crypto e core.security, incluindo aleatório seguro, hashing, HMAC, comparação em tempo constante e codificações seguras para URL
• Módulos de framework web de produção fzweb para roteamento de aplicativos, cookies, sessões, uploads multipartes, persistência, SSE, websockets e exportação OpenAPI
• fz run executa a saída nativa diretamente com streaming de texto ao vivo ou captura JSON
• Backends nativos LLVM e Cranelift com validação orientada a paridade
• Portões de liberação de memória direta:
  • python3 scripts/direct_memory_architecture_gate.py
  • python3 scripts/direct_memory_perf_gate.py
• Superfície de GPU de produção através de core.gpu, com execução Metal ao vivo no Apple mais contratos de adaptador spirv/nvptx compartilhados

Alegações de Produção

O fzy está configurado para suportar estas alegações de produção hoje: