vitte

Vitte Language — Modern Systems Programming Language

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

📖 Sommaire

Présentation
Pourquoi Vitte ?
Comparatif avec autres langages
Architecture interne
Compatibilité & Support
Download & Installation
Tutoriel complet
Exemples avancés
Syntaxe essentielle
Cas d’usage
Roadmap
Références & Documentation
Licence

🌟 Présentation

Vitte est un langage de programmation systèmes et applicatif pensé pour l’ère post-2025.
Il allie performance, sécurité mémoire et expressivité, avec une philosophie claire :

“Un langage doit vous permettre de coder vite, bien, et longtemps.”

💡 Pourquoi Vitte ?

Sûreté : pas de null implicite, borrow-checker intégré.
Performance brute : compilation en code machine optimisé via LLVM/Cranelift.
Simplicité syntaxique : inspirée de C++, Rust, et C#, mais plus concise.
Interop totale : C, C++, Rust, Zig, ASM.
Portabilité : x86_64, ARM, RISC-V, WebAssembly.

⚔ Comparatif avec autres langages

Critère	Vitte	Rust	C++17/20	Go	Zig
Sécurité mémoire	✅ Borrow-checker	✅ Borrow-checker	❌ (manuelle)	✅ GC	✅ Opt-in safety
Backend	LLVM / Cranelift / VM	LLVM	Varié	Custom	LLVM
Concurrency	✅ Threads + async/await	✅	Partiel	✅ Goroutines	✅
Cross-compilation	✅ intégrée	✅	❌	✅	✅
Package manager	✅ `vitpm` intégré	✅ Cargo	❌	✅ go mod	❌
Syntaxe	Simple & claire	Complexe	Verbose	Minimaliste	Minimaliste

🛠 Architecture interne

          ┌──────────────┐
          │   Source .vit│
          └──────┬───────┘
                 ▼
       ┌─────────────────┐
       │ Frontend         │
       │ - Lexer          │
       │ - Parser         │
       │ - Borrow Checker │
       └────────┬────────┘
                ▼
       ┌─────────────────┐
       │ Middle-end       │
       │ - IR Optimisation│
       │ - Inlining       │
       │ - Flow Analysis  │
       └────────┬────────┘
                ▼
   ┌────────────────────────┐
   │ Backend                 │
   │ - LLVM (opt)            │
   │ - Cranelift (JIT)       │
   │ - VitteVM (bytecode)    │
   └──────────┬─────────────┘
              ▼
         Exécutable binaire

🖥 Compatibilité & Support

OS / Arch	Support
Linux x86_64	✅ Stable
Linux ARM64	✅ Stable
macOS Intel	✅ Stable
macOS Apple Silicon	✅ Stable
Windows 10/11 x64	✅ Stable
FreeBSD / OpenBSD	🧪 Expérimental
RISC-V	🧪 Expérimental
WebAssembly	🚧 En cours

📥 Download & Installation

Binaires officiels

Installation via script

curl -sSL https://get.vitte.dev | sh

Installation via package managers

# Arch Linux
pacman -S vitte

# macOS (Homebrew)
brew install vitte

# Windows (Scoop)
scoop install vitte

Docker

docker run -it vitte/vitte:latest

Compilation depuis les sources

git clone https://github.com/vitte-lang/vitte.git
cd vitte
cargo build --release
./target/release/vitc --version

🚀 Tutoriel complet

1. Hello World

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

2. Projet structuré

my_app/
├── src/
│   ├── main.vit
│   └── utils.vit
├── vitte.toml
└── tests/
    └── test_main.vit

3. Compilation & exécution

vitc src/main.vit -o my_app
./my_app

4. Cross-compilation

vitc src/main.vit --target x86_64-pc-windows-gnu -o app.exe

🔬 Exemples avancés

Pattern Matching

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

Async

async do fetch() {
    await net::get("https://vitte.dev")
}

FFI C

extern(c) do printf(fmt: *u8, ...) -> i32
do main() {
    printf("Nombre: %d\n", 42)
}

📚 Syntaxe essentielle

Élément	Exemple
Déclaration	`let x = 10`
Fonction	`do add(a: i32, b: i32) -> i32 { a + b }`
Condition	`if x > 0 { ... } else { ... }`
Boucle	`for i in 0..10 { ... }`
Match	`match val { ... }`
Import	`use std::io`

🗺 Roadmap

📖 Références & Documentation

📜 Licence

Double licence :

MIT
Apache 2.0

Voir LICENSE-MIT et LICENSE-APACHE.

This site is open source. Improve this page.