Befreit von Altlasten.
Das nächste Kapitel der Systemprogrammierung.

Lyx ist nicht nur eine weitere Sprache. Native Linux x86_64, Linux ARM64 und Windows x64 Binaries — ohne libc, ohne Linker, rein über Syscalls und WinAPI.

Keine LibC.
Keine Kompromisse.

Während andere Sprachen auf riesigen Standard-Bibliotheken aufbauen, spricht Lyx direkt mit dem Linux-Kernel und der Windows API. Cross-Compilation inklusive.

  • ✓
    Linux x86_64 + ARM64 + Windows x64 Cross-Compilation
  • ✓
    Direkte Syscall/WinAPI-Kommunikation
  • ✓
    Vollständiges Module System mit std-Library
  • ✓
    Minimaler Binary-Footprint (ab 4KB)
Binary Size Complexity
Andere (dynamisch gelinkt) ~800 KB
Lyx (statisch nativ) 4-42 KB

Warum Lyx?

Die Freiheit der Direktheit. In einer Welt, in der moderne Sprachen oft riesige Runtimes und komplexe Abhängigkeiten mit sich schleppen, kehrt Lyx zu den Wurzeln der Systemprogrammierung zurück – ohne den Komfort moderner Syntax opfern zu müssen.

⚡

Zero Dependencies

Echte Binär-Autarkie. Die meisten Sprachen verlassen sich auf die C-Standardbibliothek oder externe Linker. Lyx bricht mit dieser Tradition.

  • ✓ Direkte ELF64- und PE32+-Generierung
  • ✓ Keine libc-Bindung, direkte Syscalls
  • ✓ Single-Toolchain: nur lyxc benötigt
🔗

Externe Funktionen

Du bist nicht isoliert. Lyx unterstützt die Einbindung externer Bibliotheken, wenn du sie brauchst.

  • ✓ extern fn für libc/libm Integration
  • ✓ Linux .so und Windows .DLL Support
  • ✓ PLT/GOT für dynamisches Linking
  • ✓ Varargs: printf(fmt, ...)
🔒

Sicherheit durch Typisierung

Lyx ist keine lockere Skriptsprache. Es ist für Systeme gebaut, auf die man sich verlassen muss.

  • ✓ Keine impliziten Casts – Fehler im Keim erstickt
  • ✓ var, let, co, con Speicherklassen
  • ✓ Volle Kontrolle über Veränderbarkeit
✨

Das Beste aus drei Welten

Lyx kombiniert die Stärken etablierter Sprachen zu etwas Neuem.

  • C — Die Macht der Systemprogrammierung
  • Rust — Sicherheitsansätze und strikte Typisierung
  • Pascal — Klarheit und Lesbarkeit der Syntax

Einsatzgebiete

Was kann man mit Lyx entwickeln?

🖥️

Systemprogrammierung

Direkter Hardware-Zugriff, Treiber, Betriebssystem-Komponenten. Volle Kontrolle ohne Abstraktions-Overhead.

☁️

Cloud-Native

Minimale Container-Images, Microservices, Kubernetes-ready. Ultra-kleine Binaries für maximale Dichte.

🔌

Embedded Systeme

Minimaler Footprint ab 4KB, keine Runtime erforderlich. Perfekt für eingeschränkte Umgebungen.

📚

Bildung

Klare, lesbare Syntax inspiriert von Pascal. Perfekt zum Erlernen von Systemprogrammierungs-Konzepten.

MAIN.LYX 
import std.math;

type Point = struct {
    x: int64;
    y: int64;
};

fn main(): int64 {
    // Struct-Literal mit Feldern
    var p: Point := Point { x: 10, y: 20 };
    
    // Pipe-Operator und Standard Library
    let result: int64 := -42 |> Abs64();
    
    PrintInt(p.x + result);  // 52
    return 0;
}

Einfachheit ist das
höchste Maß an Perfektion.

v0.4.0 Feature

OOP — Vollständig

Classes mit Vererbung, Konstruktoren, Destruktoren. Heap-Allokation mit new/dispose. super für Basisklassenaufrufe.

  • ✓ class extends für Single Inheritance
  • ✓ new ClassName(args) mit Konstruktor
  • ✓ dispose obj ruft Destroy()
  • ✓ super.method() für Basisklasse
type
Dog = class extends Animal {
breed: pchar;
fn Create(n, b: pchar) {
self.name := n;
self.breed := b;
}
fn speak() {
PrintStr("Woof!\n");
}
};
// Nutzung:
var d := new Dog("Buddy", "Labrador");
d.speak();
dispose d;

Cross-Compilation

Linux x86_64, Linux ARM64 und Windows x64 aus einem Codebase. Ein Compiler, drei Plattformen.

# Linux x86_64 (Standard)
./lyxc app.lyx -o app
# Linux ARM64 (Raspberry Pi, Cloud)
./lyxc app.lyx -o app --target=arm64
# Windows x64
./lyxc app.lyx -o app.exe --target=win64

Module System

Vollständiges Import/Export mit Standard Library.

import std.math;
import std.io;
import std.string;
// std/math, std/io, std/string,
// std/env, std/time, std/geo, std/crt, std.regex

Alle Modernen Features

🧩

Structs mit Methoden

Instanz-Methoden mit self, static fn, Self-Typ, Feld-Zuweisung

⚡

Pipe Operator

|> für Funktionsverkettung — lesbarer Datenfluss von links nach rechts

🔄

Type Casting

as Operator für int64/f64 Konvertierungen

Float Support — f32, f64
Arrays — [1, 2, 3], arr[i]
Struct Literals — Point { x: 10 }
Externe Funktionen — extern fn
Varargs — printf(fmt, ...)
PLT/GOT — Dynamic ELF
Speicherklassen — var, let, co, con
Globale Variablen — Top-Level var/let
switch/case — Pattern Matching
Inkrement — ++ und --
30+ Builtins — PrintInt, Random, sqrt
Null-Safety — ?, ??, ?.
CLI-Argumente — argc/argv
std.regex — Regex Engine
Debug-Flags — --emit-asm