Standard-Units Übersicht

Stand: 2026-08-12 · Verzeichnis: std/ · geprüft mit lyxc 1.0.21A

Die Standardbibliothek von Lyx umfasst 421 Units (gezählt als .lyx-Dateien unter std/), davon 27 neue Mathematik-Units — siehe Rechnen — die Mathematik-Units. Die Tabelle unten fasst den größten Teil davon in 38 Kategorien; die restlichen sind einzelne Basis-Units ohne Gruppe (std.time, std.datetime, std.env, std.log, std.error, std.result, std.conv, std.units, std.country, std.geo, std.debug, std.meta_safe, std.strtype), die weiter unten einzeln aufgeführt sind. 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.

Weil der Namensraum flach ist — es gibt keinen qualifizierten Zugriff wie std.math.Clamp64 —, tragen die Funktionen einer Unit ein gemeinsames Präfix: std.db.sqlite → SQLite*, std.net.socket → TCP*/Socket*, std.string → Str*/Char*, std.pdf.builder → Pdf*. Eigene Units sollten demselben Muster folgen.

Jede Unit wird einzeln importiert — eine import-Zeile pro Datei, die man braucht:

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

// Mehrere Units aus demselben Namespace: je eine Zeile
import std.net.http;
import std.net.dns;
import std.crypto.aes;

// LyxVision — mit std.-Präfix wie alle anderen
import std.lyxvision.app;
import std.lyxvision.button;

Nur importieren, was gebraucht wird. Jeder Import zieht die exportierten Symbole in den flachen Namensraum des Programms — und zwei Units, die denselben Namen exportieren, brechen die Übersetzung ab, noch bevor das Symbol überhaupt benutzt wird:

sema error: mehrdeutiges Symbol 'FileExists' — exportiert von 'std.fs' und 'std.fs_ext'

Bekannte Paare, die sich nicht vertragen: std.fs + std.fs_ext (FileExists, FileSize), std.math + std.ml (AbsF64, ExpF64, LogF64, SqrtF64) und std.cloud.s3 + std.datetime (DaysInMonth — transitiv über std.cloud.aws.transport → std.time, am Import nicht ablesbar). Einen Ausweg über Alias-Import oder qualifizierten Aufruf gibt es nicht — es hilft nur, eine der beiden Units wegzulassen oder den betroffenen Code in eine eigene Unit zu ziehen.

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

Der Lauf führt den Codegen mit (#1587): schlägt er fehl, entsteht keine .lyu-Datei. Eine grüne Vorkompilierung belegt damit auch die Übersetzbarkeit, nicht nur die Semantik.

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

Vierzehn Units für Ein-/Ausgabe, Betriebssystem-Interaktion, nebenläufige Programmierung, Scheduling, Signale und IPC. 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
    PrintLn(StrConcat("Starte Programm", IntToStr(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_emit statt log_info — nur log_emit beachtet Level und Ziel)
    log_emit(LOG_LEVEL_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;
    PrintLn(StrConcat(StrConcat("Dauer: ", IntToStr(elapsed)), " µs"));
}

fn LogTimestamp() {
    // FormatDate schreibt "JJJJ-MM-TT" in einen eigenen Puffer und
    // liefert die Zahl der geschriebenen Zeichen (10).
    var buf: pchar := alloc(32) as pchar;
    FormatDate(2026, 8, 19, buf);
    Print(buf);                          // "2026-08-19"
}

Zehn Units für alle Aspekte der Textverarbeitung – von einfachen String-Operationen über UTF-8 und Unicode bis zu URL-Parsing und Base64-Kodierung.

Vier Ebenen, aufeinander aufbauend. Man importiert nur, was man braucht — die Unicode-Tabellen sind groß und deshalb bewusst ausgelagert.

Dazu drei generierte Datenunits, die nicht direkt importiert werden: std.unicode_data (Normalisierung), std.unicode_casedata (Groß-/Kleinschreibung), std.unicode_gbdata (Graphem-Grenzen).

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);
    Print(host + IntToStr(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.

Vier Units zum Lesen und Schreiben von Archivformaten. ZIP und TAR unterstützen sowohl Lesen als auch Schreiben; RAR5 ist wegen der proprietären Kompression nur lesbar; ISO 9660 liest den vollständigen Verzeichnisbaum und schreibt Flat-Root-Images.

→ Archiv-Übersicht

import std.zip;

fn ZipRoundtrip(): void {
    // Schreiben
    var w: int64 := ZipWriterNew();
    ZipWriterAdd(w, "hello.txt"c, "Hallo!"c as int64, 6);
    ZipWriterSave(w, "test.zip"c);
    ZipWriterFree(w);

    // Lesen
    var z: int64 := ZipOpen("test.zip"c);
    var buf: int64 := alloc(ZipUncompSize(z, 0) + 1);
    ZipRead(z, 0, buf, ZipUncompSize(z, 0));
    PrintLn(buf as pchar);
    free(buf, ZipUncompSize(z, 0) + 1);
    ZipClose(z);
}

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);
    Print(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");
}

Sechs Units für kryptografische Grundoperationen: Verschlüsselung, Hashing, digitale Signaturen und sichere Zufallszahlen. Für TLS/HTTPS-Verbindungen wird OpenSSL via std.net.tls genutzt.

→ Übersicht: std.crypto Paket · PQC-Kategorie: std.crypto.pqc · Stärkere Hash-Funktionen und Passwort-Hashing: std.hash

Sieben Units für Linux-Kernel-Schnittstellen: asynchrones I/O, Inter-Prozess-Kommunikation, Tracing, BPF-Programme, Namespaces, Capabilities und System-Administration.

Fünf Units für direkte Datenbankverbindungen ohne ORM-Schicht. Alle Protokolle sind nativ in Lyx implementiert — keine externen Client-Bibliotheken erforderlich (Ausnahme: std.db.sqlite via libsqlite3).

In-Memory-Graphdatenbank ohne externe Abhängigkeiten. Nodes + Kanten mit typisierten Properties, f64-Embedding-Vektoren, drei Indizes (temporal, typ-basiert, Vektorähnlichkeit) und Graph-RAG-Funktion für KI-Kontext-Retrieval.

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 Grund-Units — und darüber 27 Units fürs eigentliche Rechnen, die 2026-08 dazugekommen sind: exakte Brüche, große Zahlen, genaue Elementarfunktionen, lineare Algebra, Signalverarbeitung, Graphalgorithmen.

<WRAP info> → Rechnen — die Mathematik-Units führt alle 27 mit Schichtengraph, Prüfverfahren und den drei bekannten Vorbehalten. Wer eine bestimmte Rechenaufgabe hat, fängt dort an. </WRAP>

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();
}

26 Units in vier Gruppen: Transportschicht (Sockets, TLS, epoll), Anwendungsprotokolle, Verzeichnisdienste und Netzwerk-Management. Die Units bauen aufeinander auf: HTTP nutzt Socket, HTTPS nutzt TLS, REST-Client baut auf HTTP + HTTPS auf.

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

fn FetchWeather(city: pchar): f64 {
    var resp := HttpsGet("api.example.com", StrConcat("/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

Grundlegende Funktionen:

Validierungsfunktionen für deutsche Nummernformate:

Finanz- und Wertpapiervalidierungen:

Validierungen für Fahrzeug- und Transportidentifikatoren:

Validierungen für wissenschaftliche Identifikatoren:

Länderspezifische Validierungen:

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) {
        Print("Ungültige IBAN");
        return false;
    }
    if (LuhnValidate(card) != LUHN_OK) {
        Print("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) {
    Print(IntToBin(val, 8));   // "00101010" — zweites Argument: Stellen
    Print(IntToHex(val, 2));   // "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.

unit main;
import std.io;
import std.string;
import std.lyxvision.app;
import std.lyxvision.dialog;
import std.lyxvision.button;
import std.lyxvision.group;
import std.lyxvision.consts;

fn main(): int64 {
    var prog: TProgram := ProgramNew();
    prog := ProgramInit(prog);

    var dlg: TDialog := DialogNewCentered(50, 10, "Hallo LyxVision"c);
    var btn: TButton := ButtonCreateStd(18, 6, "  OK  "c, cmOK);
    GroupInsert(dlg, btn);

    var erg: int64 := ProgramExecuteDialog(prog, dlg);
    prog := ProgramDone(prog);
    Print("Ergebnis: "); PrintLn(IntToStr(erg));
    return 0;
}

Der Importpfad lautet std.lyxvision.* — ohne das std. scheitert der Import. Details und die Namenskonvention: LyxVision.

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;
}

25 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, TrueType-Schriften, Sonderfarben, Annotationen, Formularen, eingebetteten Dateien und PDF/A-Konformität. 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: int64 := PdfAddPage(doc, 595.0, 842.0);   // A4 in Punkt
    PdfSetFont(doc, 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.builder;
import std.svg.elements;
import std.svg.style;
import std.svg.text;

// Stil setzen, Form zeichnen, mit SvgApply abschliessen —
// die Formfunktionen nehmen keinen Style-String.
var doc: int64 := SvgNew(800.0, 600.0);
SvgSetFillHex(doc, "royalblue");
SvgSetStroke(doc, 0.0, 0.0, 0.5);
SvgSetStrokeWidth(doc, 2.0);
SvgCircle(doc, 400.0, 300.0, 100.0);
SvgApply(doc);

SvgSetFillHex(doc, "white");
SvgSetFont(doc, "DejaVu Sans", 24.0);
SvgSetTextAnchor(doc, SVG_ANCHOR_MIDDLE);
SvgTextAt(doc, 400.0, 300.0, "Hallo SVG");
SvgApply(doc);

SvgSave(doc, "ausgabe.svg");     // 0 = geschrieben
SvgFree(doc);

Neun Units für native Bluetooth-Kommunikation auf Linux. Die Units decken den vollständigen Stack ab: von rohen AF_BLUETOOTH-Sockets über BlueZ-D-Bus-Kontrolle bis zu vollständigen GATT-Client-/Server-Implementierungen für Bluetooth Low Energy (BLE).

→ Details: std.hardware.bluetooth Übersicht

import std.hardware.bluetooth_gattc;
import std.hardware.bluetooth_types;

fn ReadHeartRate(target: BtAddr): int64 {
    var dev := GattcConnect(target);
    var services := GattcDiscoverServices(dev);
    var val := GattcReadChar(services[0], HEART_RATE_CHAR_UUID);
    GattcDisconnect(dev);
    return val;
}

Dreizehn Units für native USB-Host-Kommunikation auf Linux. Alle Transfers (Control, Bulk, Interrupt, Isochronous) direkt via usbdevfs-ioctls — kein libusb. Typsichere Endpoint-Wrapper und ein URB-Pool für überlappende Interrupt-Streams.

→ Details: std.hardware.usb Übersicht

import std.hardware.usb_discovery;
import std.hardware.usb_parse;
import std.hardware.usb_control;
import std.hardware.usb_bulk;

fn OpenDevice(): int64 {
  var dev: int64 := UsbAllocDevice();
  if (UsbFindDevice(0x1234, 0x5678, dev) != USB_FIND_OK) { return -1; }
  var fd: int64 := peek64(dev + 48);   // dev.handle
  UsbClaimInterface(fd, 0);
  return fd;
}

Acht Units für native GPIO-Steuerung auf dem Raspberry Pi 4 (BCM2711/ARM64). Zwei komplementäre Zugriffsmodi: MMIO-Direktzugriff (kein Syscall nach der Initialisierung — ideal für Software-PWM und Bit-Bang-Protokolle) und Linux GPIO-v2 ioctl (Multi-Pin atomar, Edge-Detection, Consumer-Labels). Typsichere Pin-Wrapper verhindern zur Compile-Zeit, dass ein Output-Pin gelesen oder ein Input-Pin geschrieben wird.

→ Details: std.hardware.gpio Übersicht

import std.hardware.gpio_mmio;
import std.hardware.gpio_pin;
import std.hardware.gpio_ext;

fn main(): int64 {
    var ctx := GpioCtxAlloc();
    GpioInit(ctx);

    // LED an Pin 18 mit typsicherem Wrapper
    var led := GpioOutputPinAlloc(ctx, 18);
    GpioOutputPinInit(led, GPIO_PULL_NONE);

    // Taster an Pin 17 mit Pull-Up
    var btn := GpioInputPinAlloc(ctx, 17);
    GpioInputPinInit(btn, GPIO_PULL_UP);

    // Software-PWM: LED dimmen (1 kHz, 50 % Duty, 2 Sekunden)
    GpioSoftPWM(ctx, 18, 1000, 50, 2000);

    GpioOutputPinFree(led);
    GpioInputPinFree(btn);
    GpioClose(ctx);
    GpioCtxFree(ctx);
    return 0;
}

Zwölf Units für nativen PCI-/PCIe-Zugriff unter Linux. Der Konfigurationsraum ist über drei austauschbare Zugriffswege erreichbar — sysfs (der Normalfall, kein Root für Lesezugriffe nötig), ECAM (speicherabgebildet, für Firmware und Bare-Metal) und Legacy-Port-I/O über 0xCF8/0xCFC. Darauf setzen Geräte-Enumeration, BAR-Dekodierung mit MMIO-Zugriff, das Durchlaufen der Capability-Liste und — über VFIO — DMA-Mapping, Geräte-Reset und Interrupts per eventfd.

Rechte: Lesen aus dem Konfigurationsraum über sysfs geht als gewöhnlicher Nutzer. BAR-Mapping, Port-I/O und VFIO verlangen erhöhte Rechte beziehungsweise ein an vfio-pci gebundenes Gerät — und im @capabilities-Manifest die entsprechenden Einträge.

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);
}

13 Units für AWS-Dienste und interne Schichten. Vollständig in Lyx implementiert — kein AWS SDK. Alle Requests werden mit AWS Signature Version 4 (SigV4) signiert.

import std.cloud.aws.core;
import std.cloud.s3;

fn main(): int64 {
    var creds: AWSCreds := AWSCredentialsDefault();
    var s3: S3Client := S3Connect(creds, "eu-central-1"c);
    S3PutObjectFile(s3, "mein-bucket"c, "bericht.pdf"c, "/tmp/bericht.pdf"c, "application/pdf"c);
    S3Close(s3);
    return 0;
}

13 Units für die DigitalOcean API v2. Authentifizierung über Bearer-Token (DOCredentials).

import std.cloud.digitalocean.credentials;
import std.cloud.digitalocean.droplets;

fn main(): int64 {
    var creds: DOCredentials := DOCredentialsFromEnv();
    var keys: array<int64> := [12345678];
    var d: DODroplet := DropletCreateSimple(creds, "web-01"c, "fra1"c,
                                            "s-2vcpu-2gb"c, "ubuntu-22-04-x64"c);
    d := DropletWait(creds, d.id, "active"c);
    var ip: int64 := DropletGetIP(creds, d.id);
    Print("IP: "c); Print(ip as pchar); PrintLn(""c);
    DODropletFree(d);
    DOCredentialsFree(creds);
    return 0;
}

16 Units für die Cloudflare API v4. Authentifizierung über API-Token (CFCredentials). CFResponse unterscheidet sich von AWS: success-Feld (1/0) statt HTTP-Statuscode.

import std.cloud.cf.credentials;
import std.cloud.cf.transport;
import std.cloud.cf.dns;

fn main(): int64 {
    var creds: CFCredentials := CFCredentialsFromEnv();
    var c: CFClient := CFClientNew(creds);

    // A-Record anlegen oder aktualisieren
    var r: CFDNSRecord := DNSRecordUpsert(c, "abc123"c, "A"c,
                                          "api"c, "1.2.3.4"c, 1, 1);
    CFDNSRecordFree(r);

    CFClientFree(c);
    CFCredentialsFree(creds);
    return 0;
}

11 Units für die Google Cloud Platform API. Authentifizierung über Application Default Credentials (GCPCredentials): Service Account (JWT RS256), Authorized User (OAuth 2.0 Refresh Token) oder GCE-Metadata-Server. Kein GCP SDK.

import std.cloud.gcp.credentials;
import std.cloud.gcp.storage;

fn main(): int64 {
    // Credential Chain: GOOGLE_APPLICATION_CREDENTIALS → ADC → GCE-Metadata
    var creds: GCPCredentials := GCPCredentialsDefault(
        "https://www.googleapis.com/auth/devstorage.read_write"c as int64);
    var gcs: GCSConn := GCSConnect(creds, "mein-projekt"c);
    var data: pchar := "Hallo GCS"c;
    GCSUpload(gcs, "mein-bucket"c, "hello.txt"c, data as int64, 9);
    GCSDisconnect(gcs);
    GCPCredentialsFree(creds);
    return 0;
}

Eigener Namensraum neben std: Diese 6 Units heißen kassensichv.* — sie liegen nicht unter std und werden auch nicht als std.kassensichv importiert. Grund ist der eigene, an Rechtslage und TSE-Zertifizierung gebundene Release-Zyklus. Noch nicht im Compiler-Paket 1.0.17K enthalten — Import schlägt derzeit fehl.

6 Units für gesetzeskonforme TSE-Anbindung nach KassenSichV, BSI TR-03153 und DSFinV-K 2.3. Vollständige Kapselung des Signierablaufs: Kassensoftware übergibt Belegdaten, erhält alle Pflichtangaben für den Bondruck — einschließlich QR-Code-String nach BSI TR-03153 Anhang A.

→ Details und Provider-Konzept: kassensichv Übersicht

import kassensichv.types;
import kassensichv.mock;
import kassensichv.manager;

fn DruckKassenbon(): void {
    var mgr: int64 := TseMockNew();   // für Tests; TseRestNew/TseFileNew für echte TSE

    var beleg: BelegDaten;
    beleg.prozessTyp   := PROZESSTYP_KASSENBELEG;
    beleg.kassenNr     := "KASSE-001"c;
    beleg.prozessDaten := "Kaffee;2.50_0.00_0.00_0.00_0.00"c;
    beleg.umsatz       := 250;   // Eurocent

    var sig: int64 := TseProcessBeleg(mgr, beleg);
    var s: SigErgebnis := sig;

    // Pflichtdaten auf Bon drucken
    PrintLn(s.tseSerial as pchar);        // TSE-Seriennummer
    PrintLn(IntToStr(s.sigZaehler));     // Signaturzähler
    PrintLn(s.qrCode as pchar);           // QR-Code-String BSI TR-03153

    SigErgebnisFree(sig);
    TseManagerFree(mgr);
}

Zwei Units für eine vollständige Proof-of-Work-Blockchain in Lyx: Transaktionen, Blöcke, kontobasierter Ledger, Mining, Kettenvalidierung und TCP-P2P-Netzwerk.

import std.blockchain;
import std.blockchain.p2p;
import std.crypto.ecc;
import std.alloc;

fn main(): int64 {
    var bc: int64 := BLBlockchainNew(1, 50000000, 100);

    // Miner-Adresse aus Public Key ableiten
    var priv: int64 := alloc(BL_PRIVKEY_LEN);
    var pub:  int64 := alloc(BL_PUBKEY_LEN);
    ECCGenerateKeyPair(priv, pub);
    var addr: int64 := alloc(BL_ADDR_LEN);
    SHA256(pub, BL_PUBKEY_LEN, addr);

    // Block minen — erster Block nach Genesis
    BLMinePendingTransactions(bc, addr);

    // P2P-Knoten starten
    var node: int64 := BLP2PNodeNew(bc, 9000);
    BLP2PNodeStart(node);

    // ... TX hinzufügen, weitere Blöcke minen, Peers verbinden ...

    BLP2PNodeFree(node);
    BLBlockchainFree(bc);
    free(priv, BL_PRIVKEY_LEN);
    free(pub,  BL_PUBKEY_LEN);
    free(addr, BL_ADDR_LEN);
    return 0;
}

Zwei Units als Grundlage für SIMD-beschleunigtes Rechnen (WP-GPU-02). Sie erkennen zur Laufzeit die CPU-Fähigkeiten und stellen 16-Byte-ausgerichtete f32-Arrays bereit. GPU-Units (std.gpu.*) sind geplant, aber noch nicht implementiert.

import std.cpu.dispatch;
import std.io;

fn main(): int64 {
    // Dispatch-Level abfragen
    var lvl: int64 := CpuDispatchLevel();
    if (lvl == CPU_DISPATCH_AVX2) {
        PrintLn("AVX2 aktiv");
    } else if (lvl == CPU_DISPATCH_SSE2) {
        PrintLn("SSE2 aktiv");
    } else {
        PrintLn("Scalar-Fallback");
    }

    // f32-Arrays anlegen (Bits: 1.0 = 0x3F800000, 2.0 = 0x40000000)
    var a: int64 := SimdAlloc(4);
    var b: int64 := SimdAlloc(4);
    var i: int64 := 0;
    while (i < 4) {
        SimdSet(a, i, 0x3F800000);  // 1.0
        SimdSet(b, i, 0x40000000);  // 2.0
        i := i + 1;
    }
    var result: int64 := SimdAdd(a, b);
    PrintLn(StrConcat(IntToStr(SimdLen(result)), " Elemente berechnet"));
    return 0;
}

Hinweis: Der Scalar-Fallback in std.cpu.dispatch ist ein Placeholder (WP-GPU-02 in Entwicklung). Echte SIMD-Instruktionen (ADDPS/VADDPS) werden vom Compiler-Codegen emittiert, wenn der Compiler f32-Ausdrücke auf SIMD-Arrays optimiert.

Neun Units zum Laden und Verarbeiten von Rasterbildern. Alle Formate werden auf ein einheitliches internes Format normalisiert: RGBA, 4 Kanäle, 8 Bit/Kanal, zeilenweise top-down. Der GrfImage-Struct (56 Bytes) ist der gemeinsame Träger.

→ Details: std.image Übersicht

import std.image.image;
import std.image.core;
import std.alloc;

fn main(): int64 {
    var img: int64 := GrfImageAlloc(0, 0);
    if (ImageDecode("foto.jpg"c, 0, img) == 0) { return 1; }

    var w: int64 := ImageGetWidth(img);
    var h: int64 := ImageGetHeight(img);
    var px: int64 := ImagePixelAt(img, w / 2, h / 2);   // Mittelpixel
    var r: int64 := (px >> 24) & 255;                    // Rotanteil

    ImageFree(img);
    return 0;
}

Vier Units für die Erstellung von ODF-konformen Dokumenten. std.office.odt erzeugt Textdokumente (.odt), std.office.ods Tabellenkalkulationen (.ods). Beide nutzen intern std.zip für das ZIP-Archiv-Format von ODF.

→ Details: std.office Übersicht

import std.office.odf_doc;
import std.office.odt;

fn main(): int64 {
    var doc: OdfDocument := new OdfDocument();   // Klasse — ohne new gibt es SIGSEGV
    doc.Init(ODF_TYPE_TEXT);
    OdtAddHeading(doc, "Bericht Q2 2026", 1);
    OdtAddParagraphStyled(doc, "Wichtig: Bitte lesen!", 1, 0);   // fett
    OdtAddParagraph(doc, "Alles in Ordnung.");
    doc.SaveToFile("bericht.odt"c);
    doc.Close();
    return 0;
}

Drei Units für Video-Container-Metadaten. Unterstützte Container: AVI und MP4/ISOBMFF. Codec-Erkennung für H.264, H.265, AV1, VP8, VP9, MPEG-4 Part 2 und MJPEG. AVI mit MJPEG-Codec unterstützt zusätzlich Frame-Extraktion und direkte Dekodierung über std.image.jpeg.

→ Details: std.video Übersicht

import std.video.core;
import std.video.mp4;
import std.alloc;
import std.io;

fn main(): int64 {
    var vid: int64 := alloc(VID_SIZE);
    if (Mp4MetaFile("film.mp4"c, 0, vid) == 0) { return 1; }

    var w:   int64 := peek64(vid + VID_OFF_WIDTH);
    var h:   int64 := peek64(vid + VID_OFF_HEIGHT);
    var dur: int64 := peek64(vid + VID_OFF_DURATION_MS) / 1000;
    PrintLn(StrConcat(StrConcat(StrConcat(StrConcat(StrConcat(IntToStr(w), "x"), IntToStr(h)), "  Dauer: "), IntToStr(dur)), "s"));

    free(vid, VID_SIZE);
    return 0;
}

Vier Units für OpenPGP nach RFC 4880. Das Paket ist eine Parser- und Codec-Bibliothek: ASCII-Armor lesen und schreiben, binäre Paket-Ströme iterieren, Public-Key-Metadaten extrahieren. Kein Schlüssel-Generieren, kein Ver-/Entschlüsseln, kein Signieren.

→ Details: std.pgp Übersicht

import std.pgp.core;
import std.pgp.armor;
import std.pgp.packet;
import std.pgp.key;
import std.alloc;

fn ReadPublicKey(armText: int64, armLen: int64): void {
    // Armor dekodieren
    var raw: int64 := alloc(armLen);
    var rawLen: int64 := PgpArmorDecode(armText, armLen, raw, armLen);
    if (rawLen < 0) { free(raw, armLen); return; }

    // Pakete iterieren
    var pkt: int64 := alloc(PGP_PKT_SIZE);
    var fp:  int64 := alloc(20);
    if (PgpPacketFirst(raw, rawLen, pkt) != 0) {
        var more: int64 := 1;
        while (more != 0) {
            var tag:  int64 := peek64(pkt + PGP_PKT_OFF_TAG);
            var body: int64 := peek64(pkt + PGP_PKT_OFF_BODY);
            var blen: int64 := peek64(pkt + PGP_PKT_OFF_BLEN);
            if (tag == PGP_TAG_PUBKEY) {
                PgpKeyFingerprint(body, blen, fp);
                // fp[0..19] = 20-Byte SHA-1 Fingerprint
            }
            more := PgpPacketNext(raw, rawLen, pkt);
        }
    }
    free(pkt, PGP_PKT_SIZE);
    free(fp, 20);
    free(raw, armLen);
}

Vier Units für HL7 Version 2 — den Datenaustauschstandard im Gesundheitswesen. Abgedeckt ist der gesamte Stack: MLLP-Framing, MSH-Parser, ACK-Engine, Patientenverwaltung (ADT), Auftragswesen (ORM/OML) und Befundübermittlung (ORU/OUL).

→ Details und Nachrichtenflüsse: std.hl7 Übersicht

import std.hl7.core;
import std.hl7.adt;
import std.alloc;

fn handleAdt(msgBuf: int64, msgLen: int64, state: int64): void {
    var msh: int64 := alloc(HL7_MSH_SIZE);
    if (Hl7MshParse(msgBuf, msgLen, msh) != HL7_OK) {
        free(msh, HL7_MSH_SIZE);
        return;
    }

    var adt: int64 := alloc(HL7_ADT_SIZE);
    Hl7AdtParse(msgBuf, msgLen, adt);

    // Patientenname und Bett ausgeben
    var fam: int64 := peek64(adt + HL7_ADT_PID + HL7_PID_FAMILY);
    var bed: int64 := peek64(adt + HL7_ADT_PV1 + HL7_PV1_LBED);

    // ACK senden
    var ackBuf: int64 := alloc(512);
    var ackLen: int64 := Hl7AckWrite(msh, "AA"c, "OK"c, ackBuf, 512);
    var outBuf: int64 := alloc(600);
    MllpFrameWrite(outBuf, 600, ackBuf, ackLen);

    free(outBuf, 600);
    free(ackBuf, 512);
    free(adt, HL7_ADT_SIZE);
    free(msh, HL7_MSH_SIZE);
}

Letzte Aktualisierung: 2026-08-16 — 27 Mathematik-Units aufgenommen (eigene Übersichtsseite, Gruppentabelle im Abschnitt Mathematik), Unit-Zahl auf 421 nachgezählt. Zuvor: Kategorien „Hardware — PCI“ und „Graphdatenbank„ ergänzt, Zahlen für Kryptografie, PDF, SVG und HL7 korrigiert, Import-Abschnitt richtiggestellt (Wildcard- und Namespace-Import gibt es nicht) und um die bekannten Symbolkollisionen erweitert. Geprüft mit lyxc 1.0.21A.