Vitte Language — Modern Systems Programming Language

Rapide comme C++, sûr comme Rust, simple comme Go — et prêt pour le futur.

---

📖 Sommaire

1. Aperçu rapide
2. Liens rapides
3. Présentation
4. Pourquoi Vitte ?
5. État du projet
6. Architecture
7. Compatibilité & cibles
8. Installation
9. Quickstart
10. Développement
11. CLI & outils
12. Éditeur & LSP
13. Exemples
14. Crates du monorepo
15. Roadmap
16. Contribuer
17. Code de conduite
18. Licence

---

🔎 Aperçu rapide

• Statut : alpha industrielle ; ABI VITBC versionnée, backends LLVM/Cranelift stabilisés et pipeline de release verrouillée.
• Toolchain : Rust 1.82.0 épinglée, pipeline stricte (fmt, clippy, test, deny).
• Debug & DX : Debugger natif + DAP intégré au LSP, diagnostics temps réel et tooling reproductible.
• Plateformes : Linux x86_64/aarch64, macOS Intel/Apple Silicon, Windows x64/ARM64, WebAssembly (WASI + std partielle) ; Android, BSD, RISC-V et embedded suivis à titre expérimental.
• Stdlib : Couverture élargie (réseau, fichiers, async) en plus des modules historiques core/IO/temps.

🔗 Liens rapides

• Architecture générale
• Guide contributeurs
• Roadmap détaillée
• Politique de sécurité
• Code de conduite

---

🌟 Présentation

Vitte est un langage systèmes & applicatif pensé pour l’ère post-2025 : performance, sûreté mémoire et expressivité sans chichis.

« Un langage doit te laisser coder vite, bien, et longtemps. »

• Sûreté : pas de null implicite, emprunts vérifiés statiquement.
• Perfs : exécution native (LLVM), JIT (Cranelift) ou VM bytecode (VITBC).
• Interop : C/C++/Rust/Zig via FFI, et WebAssembly.
• DX : LSP complet (diagnostics, complétion, go-to), CLI outillée.

❓ Pourquoi Vitte ?

• Systèmes & applicatif : un seul langage pour écrire des runtimes, des services, des outils CLI et des modules embarqués.
• Écosystème unifié : monorepo orchestrant compilateur, VM, CLI, LSP et stdlib afin de préserver la cohérence des APIs et des outils.
• Performance maîtrisée : représentation IR soignée, optimisations backend paramétrables, bytecode VITBC pour la distribution rapide.
• Expérience développeur : diagnostics riches, conventions strictes, tooling reproductible et documenté pour éviter les surprises.

---

🧭 État du projet

• MSRV : Rust 1.82.0 (épinglé via rust-toolchain.toml).
• Qualité : lints stricts (.clippy.toml), cargo deny, tests & snapshots.
• Stabilité : grammaire et IR évoluent encore ; l’ABI VITBC est versionnée.

⚠️ Jusqu’à la v1, des changements break peuvent survenir entre releases.

---

🛠 Architecture

          ┌──────────────┐
          │  Source .vit │
          └──────┬───────┘
                 ▼
       ┌─────────────────┐
       │ Front-end        │
       │  lexer, parser,  │
       │  diagnostics     │
       └────────┬────────┘
                ▼
       ┌─────────────────┐
       │   IR (CFG/DFG)   │
       │  passes & checks │
       └────────┬────────┘
                ▼
   ┌────────────────────────┐
   │ Backends               │
   │  • LLVM (opt)          │
   │  • Cranelift (JIT)     │
   │  • VM Vitte (VITBC)    │
   └──────────┬─────────────┘
              ▼
         Exécutable / Bytecode

---

🖥 Compatibilité & cibles

Support de dev quotidien : Linux x86_64/ARM64, macOS (Intel/Apple Silicon), Windows x64/ARM64, WASM (cible wasm32-wasi avec std partielle prête à l’emploi). Cibles élargies (Android, BSD, RISC-V, embedded) sont expérimentales et suivies via deny.toml.

• OS/arch suivies : voir rust-toolchain.toml (targets) et deny.toml ([graph].targets).

---

⬇️ Installation

Homebrew (macOS & Linux)

brew tap vitte-lang/vitte
brew install vitte

Depuis les sources (recommandé)

git clone https://github.com/vitte-lang/vitte.git
cd vitte

# Build workspace complet
cargo build --workspace --all-features

# Outils CLI (binaire "vitte" avec les features CLI)
cargo build -p vitte-tools --features cli --release
./target/release/vitte --help

Prérequis : Rust 1.82.0 (toolchain épinglée), composants rustfmt, clippy, rust-src, llvm-tools-preview.

Auto-complétions (bash/zsh/fish/pwsh/elvish/nu)

./target/release/vitte completions --install

Installation manuelle possible via ./target/release/vitte completions --shell <shell> --dir <chemin>.

---

⚡ Quickstart

Fichier hello.vit :

do main() {
    print("Hello, Vitte!")
}

Compile & exécute :

# Pack en VITBC puis exécute via le runtime
./target/release/vitte pack hello.vit -o hello.vitbc
./target/release/vitte run hello.vitbc

Tu as aussi vitte fmt, vitte check, vitte dump, vitte graph (voir plus bas).

---

🛠️ Développement

• make bootstrap vérifie l’environnement (utilise INSTALL=1 pour installer les composants/targets manquants listés dans rust-toolchain.toml).
• make build / make build-release exécutent un build strict (warnings → erreurs, analyse pré-build scripts/check).
• make check, make lint, make pipeline, make test… fournissent des équivalents aux pipelines CI.
• Consulte docs/development.md pour les variables utiles (VITTE_STRICT_WARNINGS, VITTE_BUILD_SKIP_ANALYSIS, options *_OPTS) et l’inventaire des outils recommandés (cargo-deny, cargo-nextest, wasm-pack, just).
• scripts/pro/ci-report.sh agrège lint + tests + arch-lint avec journaux détaillés (utilisable en CI locale ou distante).

Modes de fallback de la grammaire

Le parseur expose un mode de récupération heuristique pour améliorer l’expérience en développement (salvage des blocs, segmentation tolérante) tout en permettant une exécution stricte en CI/release.

• VITTE_FALLBACK=aggressive active les heuristiques (utile pour le REPL, les tests exploratoires et certains bridges d’AST côté outils).
• VITTE_FALLBACK=conservative applique un comportement strict (pas de rattrapage heuristique), recommandé pour la CI et les validations officielles.

Exemples:

# Tests agressifs (dev)
VITTE_FALLBACK=aggressive cargo test -p vitte-language -- --nocapture

# Grammaire stricte (profil CI/release)
VITTE_FALLBACK=conservative cargo test -p vitte-grammar

La grammaire officielle (format Vitte multi-fichier — workspace/package/data/source en blocs end) est versionnée dans grammar/vitte.ebnf et exposée dans le code via vitte_grammar::official_grammar_ebnf() (re-exporté par vitte-ast, vitte-language, vitte-language-bridge, vitte-hir et, côté outils, vitte-lsp lorsqu’il est compilé avec les features grammar ou language). Vous pouvez ainsi afficher ou intégrer la grammaire depuis n’importe quel outil sans re-synchroniser les fichiers manuellement.

Pour l’architecture (couches, frontières, dépendances autorisées), voir ARCHITECTURE.md et docs/ARCHITECTURE/overview.md.

Toutes les commandes cargo utilisent -Dwarnings par défaut via .cargo/config.toml pour garantir que la dette technique reste sous contrôle, à la manière des toolchains professionnelles C/C++/C#.

---

🧰 CLI & outils

Le binaire principal vitte regroupe les sous-commandes :

vitte
├─ fmt     # formatage des sources
├─ check   # diagnostics statiques, lints
├─ pack    # compile → VITBC (bytecode)
├─ dump    # inspecte un .vitbc (sections/CRC/compression)
├─ graph   # exports CFG/DFG (DOT)
└─ run     # exécute VITBC via le runtime/VM

Exemples :

vitte fmt src/ --write
vitte check .
vitte pack examples/fib.vit -O2 -o build/fib.vitbc
vitte dump build/fib.vitbc
vitte graph build/fib.vitbc --dot out/cfg.dot
vitte run build/fib.vitbc

### Autres outils du monorepo

Outre la commande unique `vitte`, le crate `vitte-tools` expose plusieurs binaires spécialisés :

| Binaire        | Description rapide                               | Build |
|----------------|---------------------------------------------------|-------|
| `vitte-asm`    | Assembleur `.vit.s → .vitbc`                      | `cargo build -p vitte-tools --bin vitte-asm` |
| `vitte-disasm` | Désassembleur `.vitbc → texte/JSON`               | `cargo build -p vitte-tools --bin vitte-disasm` |
| `vitte-link`   | Linker multi-chunks (fusion, déduplication, strip)| `cargo build -p vitte-tools --bin vitte-link` |
| `vitte-repl`*  | REPL expérimental (couleurs/historique inclus)    | `cargo build -p vitte-tools --bin vitte-repl --features repl-cli` |

> `*` Le REPL est actuellement livré en mode **stub** : l’interface démarre et gère l’historique/couleurs, mais signale que la compilation à la volée n’est pas encore branchée. Utile pour tester l’intégration CLI/LSP sans bloquer le build.

---

🧑‍💻 Éditeur & LSP

• LSP : vitte-lsp (VS Code, Neovim, etc.). Build : cargo build -p vitte-lsp --features stdio --release → binaire vitte-lsp. Supporte les profils stdio/tcp et expose un Debug Adapter Protocol (DAP) pour piloter le debugger intégré.

• VS Code : extension TextMate incluse (editors/vscode-vitte/). Installe via “Install from VSIX…” ou dev :

# pack rapide (depuis editors/vscode-vitte/)
npm i && npm run build   # si tu as un package.json ; sinon charge le dossier tel quel

• Coloration GitHub : .gitattributes mappe .vit & .vitte → Rust pour un highlight correct.

---

🔬 Exemples

Pattern Matching

match get_data() {
    Ok(val) => print(val),
    Err(e)  => print("Erreur: " + e),
}

Async

async do fetch() {
    await net::get("https://example.org")
}

FFI C

extern(c) do printf(fmt: *u8, ...) -> i32

do main() {
    printf("Nombre: %d\\n", 42)
}

---

🗂 Crates du monorepo

Crate	Rôle
vitte-core	Types de base, IDs, erreurs communes.
vitte-lexer	Lexeur.
vitte-parser	Grammaire + AST + diagnostics.
vitte-ast	Structures AST.
vitte-ir	IR, CFG/DFG, passes, export DOT.
vitte-vitbc	Format VITBC : lecture/écriture, sections, CRC, comp.
vitte-vm	VM/interpréteur pur.
vitte-runtime	Loader/VM, snapshots, REPL/CLI optionnels.
vitte-tools	Suite CLI : vitte (fmt/check/pack/dump/graph/run).
vitte-lsp	Serveur LSP (stdio/tcp).
vitte-wasm	Bindings WebAssembly (expérimental).
stdlib	Bibliothèque standard (pré-lude, I/O, net, fs, async).
modules/*	Modules additionnels (optionnels).
tests	Tests d’intégration E2E cross-crates.

---

🗺 Roadmap

• IR & passes de base (CFG/DFG, DOT)
• VITBC v2 (sections, CRC32, compression)
• VM & runtime (fuel, invariants)
• CLI vitte (fmt/check/pack/dump/graph/run)
• LSP initial (diagnostics, hover, completion)
• Support complet LSP (Language Server Protocol)
• Backends LLVM/Cranelift stabilisés
• Debugger + DAP
• WASM complet (WASI + std partielle)
• Stdlib étendue (net/fs/async)

---

🤝 Contribuer

• Guides : CONTRIBUTING.md
• Qualité : cargo fmt • cargo clippy -D warnings • cargo test • cargo deny check
• MSRV : 1.82.0 • unsafe interdit par défaut.
• Sécurité : signale toute vulnérabilité en privé (voir security/policy.md pour la procédure).

---

🛡️ Code de conduite

Nous appliquons le Contributor Covenant v2.1. Toute question ou signalement peut être adressé en privé à roussov@vitte-lang.org. Le respect mutuel est indispensable pour conserver un espace de collaboration bienveillant et productif.

---

📜 Licence

Triple licence : MIT OR Apache-2.0 OR BSD-3-Clause Voir LICENSE-MIT, LICENSE-APACHE, LICENSE-BSD.

---

Du code clair, des invariants solides, et la joie tranquille des builds vertes. 🟢