Zlang è un runtime bytecode nativo per il prototipo ZDOS x86_64. Il percorso già dimostrato è concreto: un file
.zlangdiventa bytecode ZLB2 v2.5, viene incorporato in un kernel bare-metal e viene eseguito durante il boot in QEMU.
| Passaggio | Componente | Prova osservabile |
|---|---|---|
| 📝 Sorgente | programs/boot.zlang |
Istruzioni emit <testo> |
| ⚙️ Compilazione | tools/zlangc.py |
Bytecode ZLB2 v2.5 e header C |
| 🧠 Runtime | kernel/zlang.c |
Validazione di magic, versione, opcode e HALT |
| 💿 Sistema | ZDOS bare-metal x86_64 | ELF Multiboot2 e immagine ISO GRUB |
| 🖥️ Verifica | QEMU + seriale | ZDOS: native Zlang program executed |
Stato preciso: Zlang non è ancora un linguaggio general purpose né ZDOS un sistema operativo generale. Variabili, funzioni, file system, rete, processi, driver, loader esterno e syscall pubbliche sono tappe future, non funzionalità già dichiarate.
Clona Zlang e ZDOS come directory affiancate. Il build ZDOS individua il compilatore Zlang in questa posizione.
git clone https://github.com/high-cde/Zlang.git
git clone https://github.com/high-cde/ZDOS.git
cd ZDOS/os/x86_64
make clean
make verify
sh tools/verify_qemu.shL’esecuzione completa deve produrre questa sequenza seriale:
ZDOS x86_64 bootstrap
Zlang runtime ZLB2 v2.5 ready
ZDOS: native Zlang program executed
ZDOS: Zlang halted cleanly
Per il build sono richiesti python3, gcc, binutils, make, grub-mkrescue, xorriso e qemu-system-x86_64.
Il profilo ZLB2 v2.5 è volutamente piccolo. Un programma usa commenti oppure l’istruzione emit.
# examples/hello.zlang
emit Ciao dal programma Zlang nativo
emit Il kernel ZDOS ha eseguito questo bytecode
Compila l’esempio in bytecode e header C:
python3 tools/zlangc.py examples/hello.zlang \
--bytecode /tmp/hello.zlb \
--header /tmp/hello.hIl compilatore rifiuta invece ciò che non appartiene ancora al profilo.
let risposta = 42
zlangc: errore: ... sintassi non supportata; il profilo ZLB2 v2.5 accetta solo 'emit <testo>'
Questo rifiuto è una garanzia: il linguaggio non promette una capacità prima di avere contratto, implementazione e test.
| Area | ✅ Disponibile | ⏳ Prossimo, ma non ancora supportato |
|---|---|---|
| Sintassi | emit <testo>, commenti #, righe vuote |
Variabili, funzioni, moduli, tipi, controllo di flusso |
| Compilatore | zlangc.py, bytecode ZLB2 v2.5, header C |
Ottimizzazioni, linker applicativo, package manager |
| Runtime | Magic, versione, opcode, lunghezze e HALT validati | Heap, error handling avanzato, scheduler, eccezioni |
| Sistema | Kernel ZDOS bare-metal x86_64 e QEMU | Loader persistente, app esterne, hardware fisico |
| Verifica | Test Python, Multiboot2, boot seriale QEMU, CI | Matrice hardware e regressioni multi-target |
Il bytecode è il patto esplicito tra compilatore e kernel. Ogni campo esiste per rendere il comportamento controllabile.
| Campo | Valore | Perché conta |
|---|---|---|
| Magic | ZLB2 |
Riconosce il formato senza ambiguità |
| Versione | 2.5 |
Permette evoluzioni compatibili e rifiuti espliciti |
Opcode 0x01 |
EMIT |
Trasferisce testo UTF-8 alla console seriale |
u16 little-endian |
Lunghezza payload | Evita letture oltre il buffer |
Opcode 0xff |
HALT |
Rende la terminazione deterministica |
Il runtime rifiuta magic, versione, opcode, lunghezza e terminazione non validi. Questo modello default-deny è il primo confine di sicurezza: ciò che non è definito dal contratto non viene eseguito implicitamente.
| Livello | Domanda | Risposta nel prototipo |
|---|---|---|
| 1. 📝 Sorgente | Cosa vuole fare il programma? | Dichiarare un messaggio con emit |
| 2. ⚙️ Compilatore | Come diventa eseguibile? | zlangc.py genera ZLB2 v2.5 |
| 3. 🧩 Contratto | Come si evita l’ambiguità? | Magic, versione, opcode, lunghezze e HALT |
| 4. 🧠 Kernel | Chi può parlare con la macchina? | Il kernel ZDOS, non il bytecode direttamente |
| 5. ✅ Verifica | Come sappiamo che funziona? | ISO, QEMU, output seriale e GitHub Actions |
Il bytecode non riceve accesso diretto a shell, rete, credenziali o file. Ogni futura syscall dovrà essere una capability esplicita, limitata, auditabile e disabilitata per default.
Il prototipo è un nucleo avviabile. L’assenza di processi, isolamento di memoria, filesystem, rete, driver, loader esterno e package manager non è nascosta: è un limite dichiarato. Prima di rendere una nuova capacità disponibile a Zlang, il progetto dovrà stabilire soggetto, capability, scope, allowlist, quota, timeout, evento di audit, errore e test negativo.
| Soglia | Nuova capacità | Evidenza richiesta prima di dichiararla supportata |
|---|---|---|
| A — File ZLB2 | Caricare bytecode esterno in sola lettura | Parsing robusto, checksum e test di file malformato |
| B — Valori | Variabili e aritmetica locale | Limiti, overflow ed errori runtime controllati |
| C — Capability | Log, tempo o input con policy | Allowlist, audit, quota, timeout e test di diniego |
| D — Più programmi | Esecuzioni cooperative | Scheduler minimo, limiti di tempo e regressioni QEMU |
| E — Distribuzione | Target installabile | Immagine firmata, release immutabile e recupero documentato |
Ogni modifica al compilatore passa prima dal contratto ZLB2: i test Python generano bytecode e header, verificano magic e versione 2.5, controllano record e HALT, quindi eseguono i controlli Rust. Il workflow usa il nome Test ZLB2 compiler contract e deve restare verde prima di integrare il compilatore con ZDOS.
La verifica end-to-end del sistema viene completata nel workflow ZDOS x86_64, che ricompila il kernel, valida l’header generato, crea l’ISO e avvia QEMU. Una release non deve essere attestata finché compiler, contratto, kernel e boot non hanno superato i rispettivi gate.
Il contratto del compilatore è coperto da test senza dipendenze esterne:
python3 -m unittest discover -s tests -p 'test_*.py' -vIl workflow GitHub Actions esegue inoltre formattazione, build, Clippy e test Rust. La prova completa del sistema passa dal README ZDOS x86_64, dal laboratorio teorico-pratico e dalla validazione CI.
| Componente | Ruolo | Collegamento |
|---|---|---|
| 🧠 ZDOS | Kernel, distro Linux e pipeline di boot | Repository ZDOS |
| 🛰️ ZDOS-SEC | HUD, feed, ledger locale e stream Socket.IO | Repository ZDOS-SEC-PORTAL |
| ⚙️ Zlang | Compilatore e contratto ZLB2 v2.5 | Questo repository |
La guida di stile e la mappa dei contratti dell’ecosistema sono disponibili in docs/ECOSYSTEM.md e docs/DOCUMENTATION_STYLE.md.
[1] Profilo tecnico ZLB2 v2.5 [6] Documento completo Zlang by ZDOS [7] ZDOS Evidence Chain [2] Architettura ZDOS x86_64 [3] Guida operativa ZDOS x86_64 [4] Laboratorio ZDOS x86_64 + Zlang [5] Workflow di validazione Zlang
Zlang + ZDOS · Build what you can prove. ✨