Standard-Units Übersicht

Stand: 2026-05-23 · Verzeichnis: std/

Die Standardbibliothek von Lyx umfasst 170 Units in 22 Kategorien. Sie folgt dem Prinzip Zero-External-Dependencies: Jede Unit ist entweder vollständig in Lyx implementiert oder wrappet direkt POSIX-Syscalls – ohne weitere Laufzeitbibliotheken als Pflichtabhängigkeit. Ausnahmen (OpenSSL, libssh2, mpg123, ALSA, Qt5) sind explizit dokumentiert und optional.

Units können einzeln oder als ganzer Namespace importiert werden:

// Einzelne Unit
import std.io;
import std.math;

// Mehrere Units aus demselben Namespace
import std.net.http;
import std.net.dns;
import std.crypto.aes;

// Wildcard: alle Units eines Namespace (praktisch für Entwicklung)
import std.audio.*;

// LyxVision (kein std.-Präfix)
import lyxvision.app;
import lyxvision.button;

Explizite Einzel-Imports sind für Produktionscode empfohlen: Der Compiler kann ungenutzte Symbole präziser warnen und das Linker-Ergebnis ist kleiner.

Units können mit dem Lyx-Compiler vorkompiliert werden. Das Ergebnis ist eine *.lyu-Datei (Lyx Unit, binär), die bereits in die interne Zwischendarstellung übersetzt wurde:

lyxc --compile-unit std/math/math.lyx
# erzeugt: std/math/math.lyu

Beim Import sucht der Compiler automatisch nach der vorkompilierten Version:

• *.lyu vorhanden → wird bevorzugt importiert (kein erneutes Parsen/Compilieren der Quelle)
• nur *.lyx vorhanden → Quellcode wird beim Build direkt mitcompiliert

Die Standardbibliothek wird in der Regel mit fertigen *.lyu-Dateien ausgeliefert. Eigene Units bei häufiger Wiederverwendung ebenfalls vorkompilieren:

# Alle Units eines Projekts vorkompilieren
lyxc --compile-unit src/utils.lyx src/config.lyx src/protocol.lyx

Kern-Units, die von fast allen anderen Units als Basis verwendet werden. In sicherheitskritischem Code (@flight_crit, @dal(A/B)) sind std.alloc und std.result die primären Bausteine für kontrollierte Ressourcen- und Fehlerbehandlung.

import std.alloc;
import std.result;

fn AllocBuffer(size: int64): ResultInt64 {
    var ptr := malloc_safe(size);
    if (ResultInt64IsErr(ptr)) {
        return ErrInt64(-1);
    }
    return ptr;
}

→ Details: Fehlerbehandlung – Result, Option, SafeArithmetic

Sieben Units für Ein-/Ausgabe, Betriebssystem-Interaktion und nebenläufige Programmierung. std.io ist die am häufigsten importierte Unit in Lyx-Programmen.

import std.io;
import std.fs;
import std.log;

fn main(): int64 {
    // Ausgabe
    PrintStr("Starte Programm\n");
    PrintInt(42);

    // Datei lesen
    var fd := FsOpen("config.ini", FS_READ);
    var buf: [1024]uint8;
    var n := FsRead(fd, ^buf[0], 1024);
    FsClose(fd);

    // Logging
    log_info("Konfiguration geladen");
    return 0;
}

Zwei komplementäre Units: std.time für Zeitwerte und hochauflösende Messungen, std.datetime für menschenlesbare Formatierung und Parsing.

import std.time;
import std.datetime;
import std.io;

fn Benchmark() {
    var start := TimeNowMicros();
    HeavyComputation();
    var elapsed := TimeNowMicros() - start;
    PrintStr("Dauer: ");
    PrintInt(elapsed);
    PrintStr(" µs\n");
}

fn LogTimestamp() {
    var ts := TimeNow();
    PrintStr(FormatDate(ts, "ISO8601"));   // "2026-05-22T14:30:00Z"
}

Fünf Units für alle Aspekte der Textverarbeitung – von einfachen String-Operationen über reguläre Ausdrücke bis zu URL-Parsing und Base64-Kodierung.

import std.string;
import std.regex;

fn ExtractVersion(input: pchar): pchar {
    // Suche nach "v1.2.3"-Muster
    var match := RegexSearch(input, "v([0-9]+\\.[0-9]+\\.[0-9]+)");
    if (match.found) {
        return match.group[1];   // Capture-Gruppe 1
    }
    return "unbekannt";
}

fn Normalize(s: pchar): pchar {
    return s |> StrTrim() |> ToLower();
}

Vier Units zum Lesen und Schreiben strukturierter Dateiformat – JSON und YAML für Web/Config, XML für Legacy-Systeme und Protokolle, INI für einfache Konfigurationsdateien.

import std.ini;
import std.io;

fn LoadConfig(): int64 {
    var cfg := IniLoad("config.ini");
    var port   := IniGetInt(cfg,  "server", "port",    8080);
    var host   := IniGetStr(cfg,  "server", "host",    "localhost");
    var debug  := IniGetBool(cfg, "app",    "debug",   false);
    PrintStr(host);
    PrintInt(port);
    return 0;
}

Acht Units für Kernalgorithmen und Low-Level-Datenoperationen. Alle Units in dieser Kategorie sind vollständig in Lyx implementiert – keine externen Abhängigkeiten.

import std.list;
import std.sort;
import std.stats;

fn AnalyzeSamples() {
    var buf: [64]int64;
    // … Werte befüllen …
    QuickSort(buf, 64);
    PrintFloat(Avg(buf, 64));
    PrintFloat(Median(buf, 64));
    PrintFloat(StdDev(buf, 64));
}

Sieben Units von 2D-Vektormathematik über GPS-Koordinaten bis zum direkten X11-Fensterzugriff.

import std.vector;
import std.geo;
import std.io;

fn PathLength(points: [16]Vec2, count: int64): f64 {
    var total: f64 := 0.0;
    for i := 1 to count - 1 do {
        var d := Sub(points[i], points[i - 1]);
        total := total + Length(d);
    }
    return total;
}

fn DistanceKm(lat1: f64, lon1: f64, lat2: f64, lon2: f64): f64 {
    return GeoHaversine(lat1, lon1, lat2, lon2);   // in Metern / 1000
}

Zwei Units für die direkte Terminal-Steuerung: std.crt für Ausgabe mit ANSI-Farben und Cursor-Kontrolle, std.crt_raw für zeichenweises non-blocking Lesen im Raw-Modus.

import std.crt;

fn PrintHeader(title: pchar) {
    CrtSetColor(CRT_GREEN, CRT_BLACK);
    CrtGoto(1, 1);
    PrintStr(title);
    CrtSetColor(CRT_DEFAULT, CRT_DEFAULT);
}

→ Für vollständige TUI-Anwendungen: LyxVision-Framework

Vier Units für Audio-Verarbeitung und -Wiedergabe. std.audio.alsa und std.audio.mpg123 setzen die entsprechenden Systembibliotheken voraus.

import std.audio.playback;

fn PlayNotification() {
    PlayWav("assets/notify.wav");
}

Zwei Units für kryptografische Grundoperationen. Für TLS/HTTPS-Verbindungen wird OpenSSL via std.net.tls genutzt.

→ Stärkere Hash-Funktionen (SHA-256, BLAKE3) und Passwort-Hashing (Argon2): std.hash

Zwei Units für direkte Datenbankverbindungen ohne ORM-Schicht. Beide implementieren das jeweilige Protokoll nativ in Lyx.

import std.db.mysql;

fn GetUserCount(): int64 {
    var conn := MysqlConnect("localhost", "app", "secret", "mydb");
    var result := MysqlQuery(conn, "SELECT COUNT(*) FROM users");
    var count := MysqlGetInt(result, 0, 0);
    MysqlClose(conn);
    return count;
}

Drei Units für mathematische Grundfunktionen. std.math.constants ergänzt typisierte Konstanten. std.math_batch ist speziell für SIMD-optimierte Mehrfach-Operationen.

import std.math;
import std.math.constants;

fn CircleArea(r: f64): f64 {
    return PI * r * r;
}

fn NormalizeAngle(deg: f64): f64 {
    return Clamp(deg, 0.0, 360.0) |> DegToRad();
}

21 Units in vier Gruppen: Transportschicht (Sockets, TLS), Anwendungsprotokolle, Verzeichnisdienste und Netzwerk-Management. Die Units bauen aufeinander auf: HTTP nutzt Socket, HTTPS nutzt TLS.

import std.net.https;
import std.json;

fn FetchWeather(city: pchar): f64 {
    var resp := HttpsGet("api.example.com", "/weather?city=" + city);
    var data := JsonParse(resp.body);
    return JsonGetFloat(data, "temperature");
}

25 Units für Prüfziffern und internationale Identifikationsnummern. Alle Units folgen dem gleichen Muster: Normalisierung → Validierung → Fehlercode. Keine externen Abhängigkeiten — vollständig in Lyx implementiert.

→ Details: std.validate Übersicht

import std.validate.iban;
import std.validate.vin;
import std.io;

fn ValidatePayment(iban_str: pchar, card: pchar): bool {
    var norm: pchar := IBANNormalize(iban_str);
    if (IBANValidate(norm) != IBAN_OK) {
        PrintStr("Ungültige IBAN");
        return false;
    }
    if (LuhnValidate(card) != LUHN_OK) {
        PrintStr("Ungültige Kartennummer");
        return false;
    }
    return true;
}

Drei Units für ML-Algorithmen, Worteinbettungen und probabilistische Logik. Alle vollständig in Lyx implementiert – kein Python, kein TensorFlow.

→ Details mit vollständigen Beispielen: ML – Detaildokumentation

import std.ml;

fn PredictHousePrice(sqm: f64, rooms: f64): f64 {
    var X: [3][2]f64;
    var y: [3]f64;
    // Trainingsdaten befüllen …
    var model := LinearRegression(X, y, 3);
    var features: [2]f64;
    features[0] := sqm;
    features[1] := rooms;
    return Predict(model, features);
}

Fünf allgemeine Hilfs-Units für häufig benötigte Querschnittsaufgaben.

import std.uuid;
import std.conv;
import std.io;

fn GenerateToken(): pchar {
    return UuidToStr(UuidV4());   // "550e8400-e29b-41d4-a716-446655440000"
}

fn PrintBitmask(val: int64) {
    PrintStr(IntToBin(val));   // "00101010"
    PrintStr(IntToHex(val));   // "2A"
}

LyxVision ist das integrierte Text-UI-Framework für terminalbasierte Anwendungen. Es ist nach dem Vorbild der klassischen Turbo Vision-Architektur aufgebaut: Ereignis-gesteuerte Widgets, Gruppen-/View-Hierarchie, modaler Dialog-Stack.

import lyxvision.app;
import lyxvision.tapplication;
import lyxvision.button;
import lyxvision.dialog;

fn main(): int64 {
    var app := TApplicationCreate("Meine App");
    var win := TWindowCreate(10, 5, 60, 20, "Hauptfenster");
    var btn := TButtonCreate(5, 10, "OK", CMD_OK);
    TGroupInsert(win, btn);
    TApplicationRun(app);
    TApplicationDestroy(app);
    return 0;
}

Fünf Units für Desktop-GUI-Anwendungen mit Qt5. Die Bindings wrappen Qt5-C++-Funktionen über FFI und ermöglichen nativen OpenGL-Zugriff über EGL und GLX. Voraussetzung: Qt5 muss auf dem Zielsystem installiert sein.

import std.qt5_app;
import std.qt5_core;

fn main(): int64 {
    var app: QApp := QAppCreate();
    QAppSetTitle(app, "Lyx-Qt5-Fenster");
    QAppRun(app);
    QAppDestroy(app);
    return 0;
}

18 Units für vollständige PDF-Erstellung und -Analyse direkt aus Lyx — ohne externe Bibliotheken. Erzeugt Standard-konforme PDFs (PDF 1.7) mit Text, Grafiken, Bildern, Annotationen, Lesezeichen und Formularfeldern. Interne Kompression über std.pdf.compress (zlib/DEFLATE).

import std.pdf;
import std.pdf.graphics;
import std.pdf.meta;

fn CreateReport(): void {
    var doc: Pdf := PdfNew();
    PdfSetTitle(doc, "Lyx Report 2026");
    PdfSetAuthor(doc, "Andreas Röne");
    var page: PdfPage := PdfAddPage(doc);
    PdfSetFont(page, "Helvetica", 14);
    PdfDrawText(page, 72.0, 720.0, "Lyx PDF-Bibliothek — Beispiel");
    PdfSave(doc, "report.pdf");
}

Zwei Units für das Lyx File Data-Format (LFD) — ein strukturiertes Binärformat für effizienten Datenaustausch zwischen Lyx-Programmen.

12 Units für programmatische Vektorgrafik-Erzeugung: Grundformen, Pfade, Text, Farbverläufe, Filter, Animationen und Einlesen vorhandener SVG-Dateien. Erzeugt standard-konforme SVG 1.1-Dateien ohne externe Abhängigkeiten.

→ Details und Architektur: std.svg Übersicht

import std.svg;

var svg: Svg := SvgNew(800.0, 600.0);
SvgCircle(svg, 400.0, 300.0, 100.0, "fill:royalblue;stroke:navy;stroke-width:2");
SvgTextAt(svg, 400.0, 300.0, "Hallo SVG", "font-size:24;text-anchor:middle;fill:white");
SvgSave(svg, "ausgabe.svg");
SvgFree(svg);

16 Units für native Android-Entwicklung über das NDK (Native Development Kit). Ermöglichen vollständige Android-Apps in Lyx ohne Java-Schicht: JNI-Typen, OpenGL ES 2.0, Sensoren, Asset-Manager, APK-Bau und Logcat-Logging.

import std.android.jni;
import std.android.log;
import std.android.gles2;

fn Java_com_example_Main_init(env: JNIEnv, obj: jobject): void {
    AndroidLog(ANDROID_LOG_INFO, "MyApp", "Native init gestartet");
    GLViewport(0, 0, 1920, 1080);
    GLClearColor(0.1, 0.1, 0.1, 1.0);
}

Letzte Aktualisierung: 2026-05-23