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).

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)
• 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. 🟢