Cyr

Warum es Cyr gibt

Wo die BEAM eine Mauer ist.

Cyra ist hervorragend in dem, worin die BEAM hervorragend ist: nebenläufige, fehlertolerante, im laufenden Betrieb neu ladbare Systeme. Doch ganze Arbeitsklassen liegen unterhalb dieser Linie. Heute muss ein Entwickler, der an die Mauer stößt, auf C, Rust oder Zig wechseln und die Sprache vollständig verlassen. Cyr ist die Notluke, die dich in der Familie hält.

⚙

LLVM, AOT

Cyr kompiliert vorab (ahead-of-time) über LLVM zu nativem Objektcode — keine VM, kein JIT. Eine eigenständige Binärdatei, die auf einer Tier-1-Plattform läuft, ohne dass etwas installiert ist.

⚡

Winzige Laufzeit: `cyrt`

Eine kleine Laufzeit, die in jede Binärdatei eingebunden wird — Allokator, Panik-Handler, Intrinsics. Ausgelegt auf wenige Hunderte Kilobyte, nicht Megabyte. Eingebettet und WASM-tauglich.

C23 FFI

@external(c, "...") ist die einzige native Interop-Fläche. Rufe C auf und werde von C aufgerufen — mit vollständigen Signaturen, expliziten Breiten und expliziter Nullbarkeit — ohne handgeschriebenen Klebecode.

✓

Gleiche Syntax, gleiche Seele

Nur switch-Fluss, Option/Result, explizite Typen — ~85% identische Grammatik zu Cyra. Das Können und der Quellcode überqueren die verwaltet/native Grenze.

Eine Sprache, zwei Dialekte

Die Verzweigung

Eine Grammatik, ein Semantikkern, zwei Backends — so wie C eine gehostete und eine freistehende Implementierung hat. Der Stamm ist die geteilte Grammatik; die beiden Zweige weichen nur dort voneinander ab, wo das Laufzeitmodell sie dazu zwingt.

// der BEAM-Dialekt

Cyra

Warm und verwaltet. Läuft auf einer Maschine.

Erlang-VM als Ziel — dynamisch, Hot Reload
Aktoren — pid / ref / port
Beliebig genaue Ganzzahlen
:erlang.* FFI · Cyra.* stdlib

// der native Dialekt

Bare Metal. Ist der Maschinencode.

LLVM als Ziel — AOT, statische Binärdatei
C23 FFI — ptr<T>, @external(c, "...")
i64 als Standard + bigint optional
cyrt Laufzeit · Cyr.* stdlib

System- & OS-Reichweite

Von deiner App bis PID 1.

Cyr zielt ausdrücklich auf systemnahe und OS-Entwicklung — bis hin zu und einschließlich eines init/PID 1, Daemons, Treiber und freistehendem Bare-Metal-Code. Je härter das Profil, desto mehr geht die Sprache aus dem Weg. Cyrs Reichweite ist in drei Ausführungsprofile gegliedert.

gehostet

App · Daemon · CLI

Ein normales natives Programm auf einem vollständigen OS. Der gesamte Stack ist verfügbar, und cyrt verwendet den OS-Heap und die OS-Threads.

vollständiges cyrt + vollständige Cyr.* stdlib + libc

freistehend-gehostet

init / PID 1 · minimale statische Binärdatei

Ein Kernel ist vorhanden, aber das Userland ist minimal. PID 1 sollte keine vollständige libc mitschleppen — eine dünne Direkt-Syscall-Schicht kommuniziert mit dem Kernel.

cyrt + Cyr.Core + dünne libc / Syscalls

bare-metal

Kernel · Bootloader · Firmware · ISR

Überhaupt kein OS. Du bringst den Allokator mit; es gibt keine Threads, keine libc, kein Unwinding. Inline-Assembler, volatile/MMIO, Atomics, eigene Einstiegspunkte.

nur cyrt-core · keine libc, kein OS-Allokator

In Aktion sehen

Nativ, explizit, eindeutig

Ein Treiber-Fragment mit C23 FFI, gepacktem Layout, Option statt null und Endrekursion, die mit konstantem Stack läuft — alles in vertrauter Cyra-Syntax.

driver.cyr

module Sensor.Driver {
    use Cyr.Result;

    // C23 FFI — the single native interop surface
    @external(c, "read_register")
    fn read_register(addr: ptr<u32>) -> u32;

    @repr(packed)
    struct Reading { id: u16; value: i32; }

    // switch-only flow; Option<T> for absence, never null
    pub fn decode(raw: u32) -> Option<Reading> {
        switch raw {
            0 => None;
            _ => Some(Reading { id: 1, value: raw as i32 });
        }
    }

    // guaranteed constant stack — TCO holds at the CIR layer
    fn sum(xs: list<i64>, acc: i64) -> i64 {
        switch xs {
            []        => acc;
            h :: rest => sum(rest, acc + h);   // i64 traps on overflow
        }
    }

    @entry
    pub fn main() -> i32 { 0; }
}

Was bereits festgelegt ist

Grundsatzentscheidungen

Cyr beginnt mit den Prämissen, die Cyra bereits geklärt hat, plus einer Reihe von Einbahnstraßen, die der Philosophierat zu Beginn ratifiziert hat. Dies sind die Erwartungen, zu denen sich Cyr verpflichtet.

i64

Kein stiller Überlauf

i64 als Standard; Arithmetik fällt in eine Falle (traps) standardmäßig. wrapping, saturating und bigint sind explizite Opt-ins.

Abwesenheit nur per Option

nil ist aus Nicht-Option-Typen verbannt. Null existiert nur hinter ptr/any an der C-Mauer.

↹

Garantiertes TCO

Rekursion in Endposition — einschließlich gegenseitiger Rekursion — läuft mit konstantem Stack. Eine semantische Garantie auf der CIR-Schicht, kein Vertrauen auf LLVM.

ARC, kein Borrow-Checker

Speicher ist ARC + optionale Arena + weak. Sicherheit wird in die Compiler-Standardwerte verlagert, nicht in autorenseitig geschriebene Lebensdauer-Annotationen — die richtige Wahl für einen LLM-verfassten Korpus.

Lautes, minimales `unsafe`

Rohe ptr<T>-Dereferenzierung und any-Down-Casts existieren nur innerhalb von unsafe — per grep auffindbar und prüfbar.

Eine eigene `Cyr.*` stdlib

Cyr schreibt seine Standardbibliothek nativ neu. Portabilität lebt in der Grammatik, nicht in den Bibliotheksnamen — eine use-Zeile ist immer ehrlich über ihren Dialekt.

Ehrliche Positionierung

Was Cyr nicht ist

Keine Neuschreibung und kein Fork

Cyr ist nicht „Cyra 2.0" und weicht syntaktisch nicht ab. Es ist eine Sprache mit zwei Backends — nicht zwei konkurrierende Sprachen.

Keine eigene Marke

Cyr ist Teil desselben Projekts — dieselben Werkzeuge, dieselbe Community — kein konkurrierendes Produkt mit eigener Identität.

Nicht das Aktorenmodell

pid, ref, port, spawn, receive, send wurden entfernt. Alles Aktorenähnliche ist eine Bibliothek, kein Sprachprimitiv.

Kein allgemeiner Systems-Pitch

Cyr ist für die Menschen, die Cyra bereits lieben und nun die Schicht unterhalb ihrer Anwendungen schreiben wollen — kein Pitch an die allgemeine Systemprogrammierungs-Öffentlichkeit.

Designphilosophie

Bewusst entschieden, ein für alle Mal

„Kontinuität von Quellcode und Können"

Peirce' pragmatische Maxime ist Cyrs Prüfstein: welchen konkreten Unterschied macht Cyr, den „Cyra plus einfach C verwenden" nicht macht? Die Antwort — Kontinuität von Quellcode und Können über die verwaltet/native Grenze hinweg — bestimmt jede Designentscheidung.

„Grammatik geteilt, Bibliothek ehrlich"

Die Dialekte teilen ~85% ihrer Syntax — das eigentlich übertragbare Gut. Sie teilen bewusst keine Bibliotheksnamen: Kohärenz gehört zu Syntax und CLI; Ehrlichkeit gehört zum Namensraum.

„Einundzwanzig Philosophen, eine Charta"

Aristotle's Vier Ursachen rahmen das Vorhaben; Popper benennt, was Erfolg widerlegen würde; Kants Antinomien halten den Rat ehrlich. Achtzehn offene Designbereiche wurden von allen einundzwanzig gelesen und die Grundsatzentscheidungen ratifiziert — der Rat läuft als organon, offen auf GitLab.