Pre-1.0 · compilatore operativo

Costruisci in piccolo.
Muoviti velocemente.

Un linguaggio di sistema incentrato sull'iterazione rapida, il controllo esplicito di basso livello e una specifica completa del linguaggio sotto le 700 righe.

Sviluppato da Aerun.ai.

ciao.sd
use "io"

fn main() -> result<i64, io_error> {
    println("Hello, world!")?
    result.ok(0)
}

Perché una nuova lingua?

seed esplora un design compatto del linguaggio di sistema con compromessi espliciti.

Lingua Compromesso seed
C/C++ Veloce ma non sicuro: segfault, buffer overflow, use-after-free Proprietà, risorse lineari, visioni lessicali e non sicure esplicite
Rust Sicuro e veloce, ma dalla complessità brutale: controllo dei prestiti, durate, tasse asincrone Nessuna sintassi a vita; le mosse, le visualizzazioni e la pulizia rimangono esplicite
Vai Semplice, ma GC mette in pausa, nessun controllo della memoria, non a livello di sistema Nessun GC; pulizia deterministica ed effetti di allocazione espliciti
Pitone/JS Produttivo, ma runtime lento, pesante, non adatto al funzionamento dei sistemi Pipeline nativa LLVM con linee di base misurate e specifiche del carico di lavoro
Java/C# VM robusto, ma prolisso, pesante, riscaldamento lento Nessuna VM o riscaldamento; il profilo runtime viene selezionato per destinazione
Tutto sopra Gli LLM li scrivono fluentemente, ma da dati di addestramento obsoleti e senza un contratto versionato per gli agenti Grammatica compatta più una competenza dell'agente con versione

Sono state progettate le lingue esistenti prima del LLM epoca. seed è progettato per questo — la specifica, il libro e la skill per agenti vengono pubblicati come un unico contratto versionato, così gli agenti programmano contro il compilatore attuale invece che da dati di addestramento obsoleti, mantenendo il controllo esplicito di sistema. La skill versionata mantiene gli agenti sullo stesso contratto di sintassi e ownership del compilatore operativo.

Perché seed?

Costruito da zero. Nessuna limitazione esterna.

Compilazioni veloci

LLVM IR è il backend canonico. L'obiettivo sono i loop edit/check stretti con build incrementali veloci. Compilazione a livello di oggetto per un'iterazione rapida.

🔒

Sicuro per costruzione

Copia scalari, risorse di solo spostamento, clone esplicito, visualizzazioni lessicali, linear t, pulizia esatta e nessun GC.

🌱

Runtime esplicito

I profili ospitati, indipendenti, kernel e runtime-nessuno rendono visibili i servizi della piattaforma e i confini non sicuri.

🚀

Bersaglio multiplo

Linux è primario; Windows x86-64 passa sotto Vino, macOS x86-64 funziona su Intel e altri obiettivi pubblicano i loro dati esatti object/link/run livello.

🔧

Orientato all'espressione

Ogni costrutto restituisce un valore. ADT, corrispondenza, ?T opzionali, propagazione del risultato con ?. Concorrenza strutturata con spawn.

💡

LLM-Nativo

Superficie compatta e verificabile: la grammatica conta ~113 regole e la specifica meno di 700 righe. Una skill versionata per agenti include la sintassi esatta e il contratto di ownership del compilatore operativo.

Ecosistema in crescita

252 Grove directory delle librerie, 11 app e 20 pacchetti in fase di compilazione nell'albero corrente. Il conteggio delle directory è l'inventario, non la disponibilità.

252
Grove directory
grove/libs/
11
App
grove/apps/
20
Pacchetti principali
compiler/llvm/libs/
283
Totale
librerie + app + core

Roadmap del prodotto

Cosa è operativo, cos’è una base testata e cosa verrà dopo.

CLI e TUI

Fondazione. G08 analisi portatile chiusa, guida, completamento, superfici, layout e istantanee. La proprietà interattiva terminal/process rimane la prossima.

Web e desktop

Fondazione/prototipo. Rete e HTTP esistono livelli politici; il web runtime integrato e un vero e proprio window/renderer ciclo di vita sono ancora aperti.

Cellulare

Android fetta operativa. Host JNI, frame Canvas, input e lavoro di esecuzione AVD per arm64/x86-64. Widget completi, accessibilità, firma e iOS rimangono aperti.

Ridge DB

Attivo v0.3. La fondazione V3-G0-G13 è completa; V3-G14-G25 possiede l'espansione della produzione locale. La v0.2 P13 è stata eliminata, non segnalata come superata.

Gioco e interfaccia utente adattiva

Prototipo. Esistono pacchetti di matematica, ora, layout, input e interfaccia utente. I prossimi passi sono il renderizzatore, l'audio, le risorse, il packaging e la base del gioco eseguibile.

ML e LLM

Fondazione dei metadati. Esistono tensori, set di dati, configurazioni di modelli e contratti di esperimenti di proprietà; i kernel numerici, l'addestramento e l'esecuzione dell'inferenza rimangono aperti.

Una copia. Ogni progetto.

No node_modules gonfiare. Nessun duplicato per progetto.

💾

Cache della versione globale

Ogni versione di ogni libreria vive una volta sotto ~/.local/lib/seed. Dieci progetti che utilizzano la stessa versione della libreria condividono una copia.

📈

Collegamento dinamico

L'impostazione predefinita crea il collegamento contro .so file nella cache. seed build --static per binari autonomi.

🔒

Sicuro per la concorrenza

flock mutex + atomico rename(2). Due progetti in corso seed install contemporaneamente non corrompono mai i download degli altri.

🗃

Rimozione automatica

seed uninstall rimuove i pacchetti in modo pulito. seed prune pulisce la cache di origine. Nessun gigabyte di depositi morti.

🛰

Amichevole offline

Una volta scaricata, la cache serve ogni build senza accesso alla rete. I file di blocco bloccano le versioni esatte in modo che le build siano riproducibili offline.

📋

Checksum verificato

Ogni versione memorizzata nella cache registra un checksum seed.lock. La manomissione o la corruzione vengono rilevate su ogni build.

Tutte le dipendenze vivono sotto ~/.local/lib/seed - non nella directory del tuo progetto.

Sintassi semplice e potente

Concetti familiari, cerimonia zero.

structs.sd
struct point {
    x: i32
    y: i32
}

fn point.distance_squared(other: point) -> i32 {
    let dx = self.x - other.x
    let dy = self.y - other.y
    dx * dx + dy * dy
}

fn main() -> i32 {
    let origin = point.{ x: 0, y: 0 }
    let target = point.{ x: 3, y: 4 }
    origin.distance_squared(target)
}
concurrency.sd
use "task"

fn main() -> i64 {
    let pair = channel_new<i32>(1).or_abort()
    let sender = pair.sender
    let receiver = pair.receiver
    spawn {
        let _done = sender.send(42)
    }
    let received = receiver.recv()
    match received.value {
        some(value) => if value == 42 { 0 } else { 1 }
        none => 2
    }
}

Cosa seed Rimuove

L'omissione è design. Ciò che tralasciamo definisce la lingua.

prendere in prestito il controllore
proprietà, risorse lineari e visioni lessicali senza sintassi di vita
async/await
concorrenza strutturata con spawn
generici di runtime
generici monomorfizzati + fns in linea
nullo
tipo opzionale ?T
eccezioni
ADT + operatore try
classi
strutture + metodi
sovraccarico dell'operatore
metodi espliciti
macro
fns in linea + generici

Direzione delle licenze

seed è attualmente proprietario e pre-release. I piani finali, i prezzi e i termini di supporto non sono stati spediti.

Contratto linguistico coerente

Il compilatore, le specifiche, il libro, le competenze dell'agente e le prove del gate si evolvono insieme attorno a un'implementazione operativa.

Le prove prima delle affermazioni

Il lavoro precedente alla versione 1.0 viene riportato tramite gate denominati, livelli target e linee di base riproducibili. La disponibilità del prodotto non è dedotta dalla presenza della fonte.

Visibilità della tabella di marcia

Le tracce di linguaggio, CLI, TUI, web, dispositivi mobili, Ridge, giochi, ML e sistemi pubblicano la fase corrente e il prossimo limite delle prove.

Il codice che scrivi è tuo. Piena proprietà. Nessuna restrizione. Nessuna royalty. Lo spedisci, lo possiedi, per sempre.

La licenza commerciale è la direzione attuale. Disponibilità concreta, verranno pubblicati i prezzi, la compatibilità e gli impegni di supporto la liberatoria che li fornisce.

Sii il primo a saperlo

seed verrà lanciato presto. Lascia la tua email e ti avviseremo non appena sarà disponibile.