Standard-Units Übersicht

Stand: 2026-06-17 · Verzeichnis: std/

Die Standardbibliothek von Lyx umfasst 356 Units in 37 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

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("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_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("Dauer: " + IntToStr(elapsed) + " µs");
}

fn LogTimestamp() {
    var ts := TimeNow();
    Print(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);
    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 as int64, "Hallo!"c as int64, 6);
    ZipWriterSave(w, "test.zip"c as int64);
    ZipWriterFree(w);

    // Lesen
    var z: int64 := ZipOpen("test.zip"c as int64);
    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 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();
}

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

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

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

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.do.credentials;
import std.cloud.do.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,
                                            keys as int64, 1);
    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);
    var gcs: GCSConn := GCSConnect(addr creds, "mein-projekt"c);
    var data: pchar := "Hallo GCS"c;
    GCSUpload(gcs, "mein-bucket"c, "hello.txt"c, data as int64, 9, "text/plain"c);
    GCSDisconnect(gcs);
    GCPCredentialsFree(creds);
    return 0;
}

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, addr beleg);
    var s: SigErgebnis := (sig as *SigErgebnis)^;

    // Pflichtdaten auf Bon drucken
    PrintLn(s.tseSerial as pchar);        // TSE-Seriennummer
    PrintLn(IntToStr(s.sigZaehler)c);     // 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(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 as int64, 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;
    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 as int64, 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(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 as int64, "OK"c as int64, 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-06-16