====== 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.

^ Kategorie ^ Units ^ Typischer Einsatz ^
| Grundsystem | 16 | Speicher, Fehlerbehandlung, I/O, Threads, Prozesse |
| Datenstrukturen | 4 | Listen, Vektoren, Hash-Tabellen, Sortieren |
| Strings & Kodierung | 10 | Suchen, Ersetzen, JSON, XML, YAML, Regex, URLs |
| Mathematik & Wissenschaft | 12 | Geometrie, Statistik, SIMD, GPS, Farben |
| KI & Maschinelles Lernen | 4 | Regression, Clustering, FastText, probabilistische Logik |
| Kryptografie | 2 | AES, SHA-1 |
| Terminal & UI | 3 | ANSI-Farben, Raw-Input, X11 |
| Qt5-Bindings | 5 | Desktop-GUI, OpenGL, EGL |
| LyxVision (TUI-Framework) | 20 | Terminal-UI, Widgets, Dialoge |
| Netzwerk & Protokolle | 23 | HTTP, DNS, SMTP, MQTT, BGP, QUIC, interne Schichten |
| Datenbanken | 3 | MySQL, Redis (voll + minimal) |
| Audio | 4 | WAV, MP3, ALSA-Wiedergabe |
| PDF-Bibliothek | 18 | PDF erstellen, lesen, annotieren, komprimieren |
| SVG-Bibliothek | 12 | Vektorgrafiken, Animationen, Filter, Parser |
| LFD-Binärformat | 2 | LFD-Dateien lesen und schreiben |
| Validierung | 25 | IBAN, EAN, ISIN, VIN, Personalausweis, Sozialversicherung |
| Android | 16 | NDK, JNI, OpenGL ES, APK-Bau, Sensoren |

===== Import-Syntax =====

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

<code lyx>
// 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;
</code>

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

==== Vorkompilierte Units (*.lyu) ====

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:

<code bash>
lyxc --compile-unit std/math/math.lyx
# erzeugt: std/math/math.lyu
</code>

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:

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

-----

===== Grundsystem =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:alloc|std.alloc]] | Heap-Speicherverwaltung: ''malloc'', ''calloc'', ''realloc'', ''free'' mit 8-Byte-Alignment; ''malloc_safe'' gibt ''ResultInt64'' zurück; ''malloc_orpanic'' terminiert bei OOM |
| [[lyx_-_programmiersprache:units:system|std.system]] | Kern-Typen: ''Handle'' und ''FD'' als benannte int64-Aliases für OS-Handles und Dateideskriptoren |
| [[lyx_-_programmiersprache:units:error|std.error]] | POSIX-errno-Konstanten (1–133), ''GetErrorMessage'', ''CheckSyscallError'', ''GetSyscallErrorCode'' |
| [[lyx_-_programmiersprache:units:result|std.result]] | ''ResultInt64'', ''ResultBool'', ''OptionInt64'' u. a.; ''Unwrap'', ''UnwrapOr'', ''Expect'', ''AndThen'' für verkettete Fehlerbehandlung ohne Exceptions |

<code lyx>
import std.alloc;
import std.result;

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

→ Details: [[lyx_-_programmiersprache:exception-handling|Fehlerbehandlung – Result, Option, SafeArithmetic]]

-----

===== I/O & Dateisystem =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:io|std.io]] | Ausgabefunktionen: ''PrintStr'', ''PrintInt'', ''PrintFloat'', ''PrintBool''; ''Printf''-Varianten für 1–4 Argumente; ''FloatToStr'', ''BoolToStr'' |
| [[lyx_-_programmiersprache:units:fs|std.fs]] | Datei-I/O über POSIX-Syscalls: ''FsOpen'', ''FsRead'', ''FsWrite'', ''FsClose'', ''FsDelete'', ''FsExists'', Pfad-Operationen |
| [[lyx_-_programmiersprache:units:os|std.os]] | Betriebssystem-Schnittstelle: ''Sleep'', ''GetPID'', ''GetEnv'', ''GetCWD'', ''Exec'', ''MemInfo'', Pfadprüfungen |
| [[lyx_-_programmiersprache:units:env|std.env]] | Kommandozeilenargumente aus ''argv'' parsen (''--key=value''-Format), ''GetArg'', ''HasFlag'' |
| [[lyx_-_programmiersprache:units:process|std.process]] | Prozessverwaltung: ''Fork'', ''Exec'', ''Spawn'', ''Wait'', ''Kill'', ''Shell'' (Befehl als String ausführen) |
| [[lyx_-_programmiersprache:units:thread|std.thread]] | POSIX-Threads: ''ThreadCreate'', ''ThreadJoin''; Mutex, Bedingungsvariablen, Thread-Local Storage, Shared Memory, Atomic-Operationen, CAS — [[lyx_-_programmiersprache:threads-nebenlaeufikeit|→ Detailseite]] |
| [[lyx_-_programmiersprache:units:log|std.log]] | Strukturiertes Logging: 5 Level (DEBUG, INFO, WARN, ERROR, FATAL), Callback-Handler, Sektionsmarkierungen, Zeitstempel |

<code lyx>
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;
}
</code>

-----

===== Zeit =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:time|std.time]] | Datum/Zeit-Typen, Unix-Zeitstempel (Sekunden und Mikrosekunden), hochauflösende Timer (''TimeNowMicros''), Zeitzonen-Offset |
| [[lyx_-_programmiersprache:units:datetime|std.datetime]] | Formatierung (ISO 8601, RFC 2822, relative Zeitangaben) und Parsing von Datums-/Zeitstrings; ''FormatDate'', ''ParseDate'' |

<code lyx>
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"
}
</code>

-----

===== Strings & Textverarbeitung =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:string|std.string]] | String-Operationen: ''StrLen'', ''StrCopy'', ''StrConcat'', ''StrFind'', ''StrReplace'', ''StrTrim'', ''StrSplit'', ''ToUpper'', ''ToLower''; ''StringBuilder'' für effizientes Zusammensetzen |
| [[lyx_-_programmiersprache:units:regex|std.regex]] | Reguläre Ausdrücke: ''RegexMatch'', ''RegexSearch'', ''RegexReplace'', Capture-Gruppen, Flags (case-insensitive, multiline) |
| [[lyx_-_programmiersprache:units:html|std.html]] | HTML-Escape/Unescape, Tag-Erkennung, ''StripTags'', Validierung der Tag-Balance |
| [[lyx_-_programmiersprache:units:url|std.url]] | URL-Parsing nach RFC 3986: Schema, Host, Pfad, Query-Parameter; Prozent-Kodierung, ''UrlBuild'' |
| [[lyx_-_programmiersprache:units:base64|std.base64]] | Base64-Kodierung/Dekodierung (Standard und URL-Safe), Basic-Auth-Header, Data-URLs |

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

-----

===== Datenformate =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:json|std.json]] | JSON-Parser und -Serialisierer: ''JsonParse'', ''JsonGet'', ''JsonSet'', ''JsonToStr''; alle JSON-Typen (Objekt, Array, String, Zahl, Bool, null) |
| [[lyx_-_programmiersprache:units:xml|std.xml]] | XML-Parser und -Generator: Elemente, Attribute, Namespace, Pretty-Print, Basis-Validierung |
| [[lyx_-_programmiersprache:units:yaml|std.yaml]] | YAML-Parser: Skalare, Sequenzen, Maps; pfadbasierter Zugriff (''YamlGetPath''), Datei-Load/Save |
| [[lyx_-_programmiersprache:units:ini|std.ini]] | INI-Konfigurationsdateien: Sektionen, typisierte Getter (''IniGetStr'', ''IniGetInt'', ''IniGetBool''), Datei-Load/Save |

<code lyx>
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;
}
</code>

-----

===== Datenstrukturen & Algorithmen =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:buffer|std.buffer]] | Byte-Buffer-Operationen: ''BufCopy'', ''BufFill'', ''BufFind'', ''BufReverse'', Hex-Kodierung/Dekodierung |
| [[lyx_-_programmiersprache:units:list|std.list]] | Datenstrukturen für int64 und Vec2: dynamische Liste, ''StaticList'' (Stack-alloziert), Stack, Queue, RingBuffer |
| [[lyx_-_programmiersprache:units:hash|std.hash]] | Hash-Funktionen: FNV1a, MD5, SHA-256, SHA-3 (256/512), BLAKE3; Passwort-Hashing: bcrypt, Argon2, scrypt |
| [[lyx_-_programmiersprache:units:sort|std.sort]] | QuickSort für int64-Arrays (Median-of-Three-Pivot, Insertion-Sort-Fallback bei n ≤ 16) |
| [[lyx_-_programmiersprache:units:stats|std.stats]] | Array-Statistik: ''Sum'', ''Min'', ''Max'', ''Avg'', ''Median'', ''Variance'', ''StdDev'' |
| [[lyx_-_programmiersprache:units:stats_batch|std.stats_batch]] | Batch-Statistik für 4 oder 8 direkt übergebene Werte (ohne Array-Allokation, SIMD-freundlich) |
| [[lyx_-_programmiersprache:units:pack|std.pack]] | Binäres Serialisieren/Deserialisieren: VarInt (LEB128), Int8–64, Float, String, Arrays; Little/Big-Endian |
| [[lyx_-_programmiersprache:units:zlib|std.zlib]] | DEFLATE/zlib-Kompression (RFC 1950/1951): ''Compress'', ''Decompress'', LZ77, Adler-32, CRC32 |

<code lyx>
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));
}
</code>

-----

===== Geometrie & Grafik =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:vector|std.vector]] | Vec2-Vektormathematik: ''Add'', ''Sub'', ''Scale'', ''Dot'', ''Cross'', ''Normalize'', ''Rotate'', ''Lerp'', ''Length'' |
| [[lyx_-_programmiersprache:units:vector_batch|std.vector_batch]] | Batch-Operationen auf Vec2-Arrays: Summe, Skalierung, Normalisierung (SIMD-optimiert) |
| [[lyx_-_programmiersprache:units:rect|std.rect]] | Rechteck-Geometrie: ''Contains'', ''Inflate'', ''Union'', ''Intersect'', ''Clamp'' |
| [[lyx_-_programmiersprache:units:circle|std.circle]] | Kreis-Geometrie, 1D/2D-Bereichstypen (''Range'', ''Range2D''), Überlappungsprüfung |
| [[lyx_-_programmiersprache:units:color|std.color]] | RGBA-Farben (uint32-gepackt): ''Blend'', ''ToHSL'', ''FromHSL'', ''Brighten'', ''Saturate'', ''Lerp'' |
| [[lyx_-_programmiersprache:units:geo|std.geo]] | GPS-Koordinaten (WGS-84): Haversine-Distanz, Bearing, Bounding-Boxes, Dezimal/DMS-Konvertierung |
| [[lyx_-_programmiersprache:units:x11|std.x11]] | X11-Fenster-System (direkte Xcb/Xlib-Syscalls): Display öffnen, Fenster erstellen, Zeichnen, Tastatur-/Mausereignisse |

<code lyx>
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
}
</code>

-----

===== Terminal =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:crt|std.crt]] | Terminal-Ausgabe: ANSI-Farben (16 Vordergrund-/Hintergrundfarben), Cursor-Positionierung, Bildschirm löschen, ''CrtGoto'', ''CrtSetColor'' |
| [[lyx_-_programmiersprache:units:crt_raw|std.crt_raw]] | Roh-Terminal-I/O: Raw-Modus via ''tcgetattr''/''tcsetattr'', zeichenweises non-blocking Lesen, Escape-Sequenz-Erkennung |

<code lyx>
import std.crt;

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

→ Für vollständige TUI-Anwendungen: [[lyx_-_programmiersprache:units:lyxvision:app|LyxVision-Framework]]

-----

===== Audio =====

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

^ Unit ^ Abhängigkeit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:audio|std.audio]] | keine | Audio-Basis: ''AudioInfo''-Typ, WAV-Parser, WAV-Schreiben, PCM-Format-Konvertierung, MP3-Header-Erkennung |
| [[lyx_-_programmiersprache:units:audio:alsa|std.audio.alsa]] | libasound | ALSA-Soundkarte: direkte PCM-Wiedergabe und Aufnahme über Kernel-Interface, Buffer-Konfiguration |
| [[lyx_-_programmiersprache:units:audio:mpg123|std.audio.mpg123]] | libmpg123 | MP3-Dekodierung via mpg123-Bibliothek, Stream-basiert, automatisches Resampling |
| [[lyx_-_programmiersprache:units:audio:playback|std.audio.playback]] | aplay/ALSA | Vereinfachte WAV-Wiedergabe: ''PlayWav(filename)'' ohne manuelle ALSA-Konfiguration |

<code lyx>
import std.audio.playback;

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

-----

===== Kryptografie =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:crypto:aes|std.crypto.aes]] | AES-128/256 im CBC-Modus: ''AesEncrypt'', ''AesDecrypt'', PKCS#7-Padding, zufälliger IV-Generator |
| [[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]] | SHA-1 (160-Bit-Hash): ''Sha1Hash'', ''Sha1HexStr''; Legacy-Einsatz (MySQL Native Password, Git-Objekt-IDs) |

→ Stärkere Hash-Funktionen (SHA-256, BLAKE3) und Passwort-Hashing (Argon2): [[lyx_-_programmiersprache:units:hash|std.hash]]

-----

===== Datenbanken =====

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

^ Unit ^ Port ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:db:mysql|std.db.mysql]] | 3306 | MySQL-Client über Protokoll 41 (TCP): Verbindungsaufbau, Abfragen, Prepared Statements, Ergebnis-Iteration |
| [[lyx_-_programmiersprache:units:db:redis|std.db.redis]] | 6379 | Redis-Client via RESP-Protokoll (voll): Strings, Lists, Hashes, Sets, Sorted Sets, Pub/Sub, Expire, Pipelining |
| [[lyx_-_programmiersprache:units:db:redis_simple|std.db.redis_simple]] | 6379 | Redis-Client (minimal): nur GET/SET/DEL/EXPIRE — für eingeschränkte Umgebungen ohne std.string-Abhängigkeit |

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

-----

===== Mathematik =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:math|std.math]] | Ganzzahl- und Gleitkomma-Mathematik: ''Abs'', ''Min'', ''Max'', ''Sqrt'', ''Sin'', ''Cos'', ''Tan'', ''Lerp'', ''Map'', ''Clamp'', ''Pow'', ''Atan2'', ''Floor'', ''Ceil'', ''Round'' |
| [[lyx_-_programmiersprache:units:math_batch|std.math_batch]] | Batch-Min/Max/Clamp für 4 oder 8 Argumente gleichzeitig – ohne Array-Overhead, SIMD-freundlich |
| [[lyx_-_programmiersprache:units:math:constants|std.math.constants]] | Typisierte mathematische Konstanten: π, e, √2, φ (Goldener Schnitt), Tau; Grad-/Radiant-Konvertierung |

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

-----

===== Netzwerk & Protokolle =====

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

^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:net:socket|std.net.socket]] | Transport | TCP, UDP, Unix, Raw-Sockets, ICMP, ARP; ''Poll'', ''Select'' für non-blocking I/O |
| [[lyx_-_programmiersprache:units:net:types|std.net.types]] | Transport | Socket-Adresstypen (''SockAddr4'', ''SockAddr6''), IP-Hilfsfunktionen (''IpFromStr'', ''IpToStr'') |
| [[lyx_-_programmiersprache:units:net:tls|std.net.tls]] | Transport | TLS/SSL-Verbindungen (via OpenSSL): Handshake, Zertifikat-Prüfung, Lesen/Schreiben |
| [[lyx_-_programmiersprache:units:net:syscalls|std.net.syscalls]] | Transport | Portable POSIX-Socket-Syscall-Wrapper (unterste Schicht; selten direkt verwendet) |
| [[lyx_-_programmiersprache:units:net:dns|std.net.dns]] | Protokolle | DNS-Auflösung: A, AAAA, MX, NS, TXT, SOA, SRV, CAA, DNSKEY, DS, PTR |
| [[lyx_-_programmiersprache:units:net:http|std.net.http]] | Protokolle | HTTP/1.1-Client: GET, POST, PUT, DELETE; Header, Chunked-Transfer, Redirect-Follow |
| [[lyx_-_programmiersprache:units:net:https|std.net.https]] | Protokolle | HTTPS-Client (baut auf ''std.net.tls'' auf); identische API wie ''std.net.http'' |
| [[lyx_-_programmiersprache:units:net:smtp|std.net.smtp]] | Protokolle | SMTP-Mailversand (Ports 25/587/465): vollständiger Dialog, STARTTLS, AUTH LOGIN |
| [[lyx_-_programmiersprache:units:net:imap|std.net.imap]] | Protokolle | IMAP4rev1-Postfachzugriff: SELECT, LIST, FETCH, SEARCH, tagged Responses |
| [[lyx_-_programmiersprache:units:net:ssh|std.net.ssh]] | Protokolle | SSH-Verbindung: Passwort- und Key-Auth, Remote-Befehlsausführung, Output-Capture |
| [[lyx_-_programmiersprache:units:net:mqtt|std.net.mqtt]] | Protokolle | MQTT 3.1.1: Connect, Publish, Subscribe, QoS 0/1/2 – für IoT-Geräte |
| [[lyx_-_programmiersprache:units:net:ntp|std.net.ntp]] | Protokolle | NTP v3: Zeitabfrage via UDP Port 123, Offset-Berechnung |
| [[lyx_-_programmiersprache:units:net:quic|std.net.quic]] | Protokolle | QUIC (RFC 9000): UDP-basiert, TLS 1.3 integriert, Grundlage für HTTP/3-Transport |
| [[lyx_-_programmiersprache:units:net:sip|std.net.sip]] | Protokolle | SIP (RFC 3261): REGISTER, INVITE, OPTIONS; 1xx–6xx-Statusklassen (VoIP) |
| [[lyx_-_programmiersprache:units:net:telnet|std.net.telnet]] | Protokolle | Telnet (RFC 854): Option-Negotiation, Legacy-Gerätekommunikation (Switches, PLCs) |
| [[lyx_-_programmiersprache:units:net:whois|std.net.whois]] | Protokolle | WHOIS (RFC 3912): Auto-Routing zu Registry-Servern (.com/.de/.eu/IP) |
| [[lyx_-_programmiersprache:units:net:ldap|std.net.ldap]] | Verzeichnis | LDAP (RFC 4511): Bind, Search, Modify, Add, Delete, SASL-Auth (Active Directory / OpenLDAP) |
| [[lyx_-_programmiersprache:units:net:bgp|std.net.bgp]] | Routing | BGP-4 (RFC 4271): FSM IDLE→ESTABLISHED, AS-Routing, UPDATE-Messages, Path-Attribute |
| [[lyx_-_programmiersprache:units:net:snmp|std.net.snmp]] | Management | SNMPv1/v2c: OID-basierter Geräteparameter-Zugriff (GET/SET/WALK) |
| [[lyx_-_programmiersprache:units:net:asn1|std.net.asn1]] | Management | ASN.1/BER-Encoding für SNMP-PDUs (interne Hilfsbibliothek, selten direkt verwendet) |
| [[lyx_-_programmiersprache:units:net:mongo|std.net.mongo]] | Datenbank | MongoDB Wire Protocol: BSON-Dokumente, Insert/Find/Update/Delete, SCRAM-SHA-1-Auth |
| ''std.net.internal.syscalls_linux'' | Intern | Linux-spezifische Socket-Syscall-Wrapper — wird automatisch von std.net.syscalls gezogen |
| ''std.net.internal.types'' | Intern | Interne Networking-Typ-Aliases — nicht direkt importieren |

<code lyx>
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");
}
</code>

-----

===== Validierung =====

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: [[lyx_-_programmiersprache:units:validate|std.validate Übersicht]]

==== Basis ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:ean|std.validate.ean]] | EAN-8/13/14, UPC-A Barcode-Validierung mit Prüfziffer-Berechnung und Länder-Präfix-Erkennung |
| [[lyx_-_programmiersprache:units:validate:iban|std.validate.iban]] | IBAN-Validierung (Mod-97-Algorithmus, 30+ Länder), Bankleitzahl- und Kontonummer-Extraktion |
| [[lyx_-_programmiersprache:units:validate:isbn|std.validate.isbn]] | ISBN-10/13-Validierung, bidirektionale Konvertierung (10↔13), ISSN-Support |
| [[lyx_-_programmiersprache:units:validate:luhn|std.validate.luhn]] | Luhn-Algorithmus: Kreditkarten (Typ-Erkennung: Visa/MC/Amex/…), IMEI, deutsche Steuer-ID |
| [[lyx_-_programmiersprache:units:validate:vat|std.validate.vat]] | EU-Umsatzsteuer-ID-Validierung für alle 26 EU-Mitgliedstaaten (Muster + Prüfziffer) |

==== Deutsche Nummern ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:de_personal|std.validate.de_personal]] | MRZ, Steuer-ID, Rentenversicherungsnummer (RVNR), eGK-Versichertennummer |
| [[lyx_-_programmiersprache:units:validate:de_numbers|std.validate.de_numbers]] | PZN (Arzneimittel), WKN (Wertpapiere), AGS (Gemeindeschlüssel), Zählpunktbezeichnung |

==== Internationale Wertpapiere & Finanz ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:isin|std.validate.isin]] | ISIN (ISO 6166) — weltweite Wertpapierkennung, Luhn auf erweiterter Ziffernkette |
| [[lyx_-_programmiersprache:units:validate:lei|std.validate.lei]] | LEI (ISO 17442) — Legal Entity Identifier, Mod-97 wie IBAN |
| [[lyx_-_programmiersprache:units:validate:bic|std.validate.bic]] | BIC/SWIFT-Code (ISO 9362) — strukturelle Bankidentifikation |
| [[lyx_-_programmiersprache:units:validate:us_cusip|std.validate.us_cusip]] | CUSIP — US/kanadische Wertpapierkennung, gewichtetes Mod-10 |

==== Fahrzeuge & Transport ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:vin|std.validate.vin]] | VIN/FIN (FMVSS 565, ISO 3779) — Fahrzeugidentifikationsnummer, Mod-11 |
| [[lyx_-_programmiersprache:units:validate:iso6346|std.validate.iso6346]] | ISO 6346 — Schiffscontainer-Nummer, Zweierpotenzen Mod-11 |
| [[lyx_-_programmiersprache:units:validate:uic|std.validate.uic]] | UIC-Fahrzeugnummer — Eisenbahnfahrzeuge, Luhn Mod-10 |
| [[lyx_-_programmiersprache:units:validate:iata|std.validate.iata]] | IATA-Ticketnummer und Air Waybill — Mod-7 |
| [[lyx_-_programmiersprache:units:validate:mmsi|std.validate.mmsi]] | MMSI — Seefunk-Identifikation, ITU MID strukturell |

==== Wissenschaft & Publikationen ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:issn|std.validate.issn]] | ISSN (ISO 3297) — Zeitschriften, Mod-11 |
| [[lyx_-_programmiersprache:units:validate:ismn|std.validate.ismn]] | ISMN (ISO 10957) — Notendrucke, EAN-13-Profil Präfix 9790 |
| [[lyx_-_programmiersprache:units:validate:isrc|std.validate.isrc]] | ISRC (ISO 3901) — Tonaufnahmen, strukturell CC-XXX-YY-NNNNN |
| [[lyx_-_programmiersprache:units:validate:orcid|std.validate.orcid]] | ORCID iD — Wissenschaftler-ID, ISO/IEC 7064 MOD 11-2 |
| [[lyx_-_programmiersprache:units:validate:cas|std.validate.cas]] | CAS-Nummer — chemische Verbindungen, rechtsseitig gewichtetes Mod-10 |

==== Länderspezifisch ====

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:validate:nl_bsn|std.validate.nl_bsn]] | NL BSN (Burgerservicenummer) — 9-Proef Mod-11 |
| [[lyx_-_programmiersprache:units:validate:ch_ahv|std.validate.ch_ahv]] | CH AHV-Nummer — EAN-13 Mod-10, Präfix 756 |
| [[lyx_-_programmiersprache:units:validate:us_ssn|std.validate.us_ssn]] | US SSN (Social Security Number) — strukturell, bekannte Muster ausgeschlossen |
| [[lyx_-_programmiersprache:units:validate:ewc|std.validate.ewc]] | EWC/AVV-Abfallschlüssel — EU-Abfallkatalog, strukturell |

<code lyx>
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;
}
</code>

-----

===== KI & Maschinelles Lernen =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:ml|std.ml]] | ML-Kern: lineare Regression, logistische Regression, KNN, K-Means, Naive Bayes; Normalisierung (MinMax, Z-Score); Metriken (MSE, MAE, R², Accuracy) |
| [[lyx_-_programmiersprache:units:ml_full|std.ml_full]] | ML-Vollversion: alle std.ml-Algorithmen plus Entscheidungsbäume (Gini/Entropy/Chi²), Random Forest, Gradient Boosting, SVM (linear) |
| [[lyx_-_programmiersprache:units:fasttext|std.fasttext]] | FastText-Worteinbettungen: Skip-gram/CBOW-Training (SGD), ''FindNearest'', Analogien, Klassifikation, Save/Load |
| [[lyx_-_programmiersprache:units:qbool|std.qbool]] | Probabilistischer Boolean (''qbool''): Wahrscheinlichkeits-basierte Logik-Operationen, fuzzy Entscheidungen mit ''Observe()'', ''QBoolAnd'', ''QBoolOr'' |

→ Details mit vollständigen Beispielen: [[lyx_-_programmiersprache:ml|ML – Detaildokumentation]]

<code lyx>
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);
}
</code>

-----

===== Utilities =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:conv|std.conv]] | Zahlensystemkonvertierung: Hex, Binär, Oktal; Bitmanipulation (''SetBit'', ''ClearBit'', ''TestBit''); Endian-Umwandlung (''SwapU16'', ''SwapU32'', ''SwapU64'') |
| [[lyx_-_programmiersprache:units:country|std.country]] | ISO 3166-1-Länderdatenbank (249 Länder): Code ↔ Name, Währung, TLD, Telefon-Präfix, Region/Subregion |
| [[lyx_-_programmiersprache:units:uuid|std.uuid]] | UUID-Generierung v4 (zufällig, RFC 4122) und v7 (zeitbasiert, monoton sortierbar, RFC 9562); ''UuidToStr'', ''UuidFromStr'' |
| [[lyx_-_programmiersprache:units:systeminfo|std.systeminfo]] | Systeminformationen aus ''/proc'': CPU-Kerne, RAM-Gesamt/Frei, Load-Average (1/5/15 min), Uptime, Hostname |
| [[lyx_-_programmiersprache:units:units.lyx|std.units]] | Physikalische Einheitentypen (Meter, Kilogramm, Sekunde, …) und Konvertierungen (km/h ↔ m/s, °C ↔ °F, …) |

<code lyx>
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"
}
</code>

-----

===== LyxVision (TUI-Framework) =====

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.

<code lyx>
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;
}
</code>

^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:lyxvision:main|lyxvision.main]] | Kern | Framework-Einstiegspunkt, Terminal-Helper-Funktionen |
| [[lyx_-_programmiersprache:units:lyxvision:app|lyxvision.app]] | Kern | ''TProgram'' – Anwendungsschleife, Ereignis-Dispatch |
| [[lyx_-_programmiersprache:units:lyxvision:tapplication|lyxvision.tapplication]] | Kern | ''TApplication'', ''TDesktop'', Menü- und Statusleiste |
| [[lyx_-_programmiersprache:units:lyxvision:drivers|lyxvision.drivers]] | Kern | Low-Level Terminal-Treiber (ANSI, xterm, Linux-Konsole) |
| [[lyx_-_programmiersprache:units:lyxvision:types|lyxvision.types]] | Typen | ''TEvent'', ''TPoint'', ''TRect'', Ereigniskonstanten (Maus, Tastatur, Befehl) |
| [[lyx_-_programmiersprache:units:lyxvision:consts|lyxvision.consts]] | Typen | Farben (16 Paare), View-Flags, State-Flags, Draw-Flags, Cursor-Stile |
| [[lyx_-_programmiersprache:units:lyxvision:view|lyxvision.view]] | Views | ''TView'' – Basis-Darstellungsobjekt; Draw, HandleEvent, SetState |
| [[lyx_-_programmiersprache:units:lyxvision:group|lyxvision.group]] | Views | ''TGroup'' – Container für Views; Insert, Delete, Broadcast |
| [[lyx_-_programmiersprache:units:lyxvision:window|lyxvision.window]] | Views | ''TWindow'' – Rahmenfenster mit Titelleiste, Zoom, Resize |
| [[lyx_-_programmiersprache:units:lyxvision:dialog|lyxvision.dialog]] | Views | ''TDialog'' – modaler Dialog; ExecView, Ergebnis-Handling |
| [[lyx_-_programmiersprache:units:lyxvision:frame|lyxvision.frame]] | Views | ''TFrame'' – Rahmenzeichnung (einfach/doppelt), Schatten |
| [[lyx_-_programmiersprache:units:lyxvision:button|lyxvision.button]] | Widgets | ''TButton'' – Schaltfläche mit Befehl, Tastaturkürzel, Focus |
| [[lyx_-_programmiersprache:units:lyxvision:cluster|lyxvision.cluster]] | Widgets | ''TCluster'' – Radio-Button- und Checkbox-Gruppe |
| [[lyx_-_programmiersprache:units:lyxvision:inputline|lyxvision.inputline]] | Widgets | ''TInputLine'' – Texteingabefeld mit Validierungs-Callback |
| [[lyx_-_programmiersprache:units:lyxvision:listview|lyxvision.listview]] | Widgets | ''TListView'' – scrollbare Listenansicht, selektierbare Einträge |
| [[lyx_-_programmiersprache:units:lyxvision:menu|lyxvision.menu]] | Widgets | ''TMenu'', ''TMenuBar'', ''TSubMenu'' – vollständiges Menüsystem |
| [[lyx_-_programmiersprache:units:lyxvision:statictext|lyxvision.statictext]] | Widgets | ''TStaticText'' – statische Textanzeige, mehrzeilig |
| [[lyx_-_programmiersprache:units:lyxvision:staticline|lyxvision.staticline]] | Widgets | ''TStaticLine'' – horizontale/vertikale Trennlinie |
| [[lyx_-_programmiersprache:units:lyxvision:terminal|lyxvision.terminal]] | Widgets | ''TTerminal'' – eingebetteter ANSI-Terminal-Emulator |
| [[lyx_-_programmiersprache:units:lyxvision:textdevice|lyxvision.textdevice]] | Widgets | ''TTextDevice'' – scrollbarer Textpuffer für Log-Ausgaben |

-----

===== Qt5-Bindings =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:qt5_app|std.qt5_app]] | Qt5-Anwendungslebenszyklus: ''QApplication'' initialisieren, Event-Loop starten und beenden |
| [[lyx_-_programmiersprache:units:qt5_core|std.qt5_core]] | Qt5 Core-Modul: ''QString'', ''QVariant'', Signale/Slots-Infrastruktur |
| [[lyx_-_programmiersprache:units:qt5_egl|std.qt5_egl]] | Qt5 EGL-Surface-Bindings für Embedded-Linux und Wayland-Targets |
| [[lyx_-_programmiersprache:units:qt5_gl|std.qt5_gl]] | Qt5 OpenGL-Bindings: ''QOpenGLContext'', ''QOpenGLFunctions'', Shader |
| [[lyx_-_programmiersprache:units:qt5_glx|std.qt5_glx]] | Qt5 GLX-Bindings für X11-OpenGL (klassisches Desktop-Linux) |

<code lyx>
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;
}
</code>

-----

===== PDF-Bibliothek =====

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).

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:pdf|std.pdf]] | Öffentliche PDF-API: ''PdfNew'', ''PdfSave'', ''PdfAddPage'' — Einstiegspunkt für alle PDF-Operationen |
| [[lyx_-_programmiersprache:units:pdf:objects|std.pdf.objects]] | Primitive für PDF-Buffer: Byte-Schreiboperationen, Objekt-Nummerierung |
| [[lyx_-_programmiersprache:units:pdf:builder|std.pdf.builder]] | Dokument-Builder: Cross-Reference-Tabelle, Trailer, Objekt-Flattening |
| [[lyx_-_programmiersprache:units:pdf:page|std.pdf.page]] | Seitenverwaltung: ''PdfAddPage'', ''PdfSetLandscape'', Seitengrößen (A4, Letter …) |
| [[lyx_-_programmiersprache:units:pdf:fonts|std.pdf.fonts]] | Standard-14-Schriftarten-Konstanten und AFM-Metrik-Tabellen |
| [[lyx_-_programmiersprache:units:pdf:graphics|std.pdf.graphics]] | Content-Stream: Text ausgeben, Pfade zeichnen, Farben setzen, Transformationen |
| [[lyx_-_programmiersprache:units:pdf:compress|std.pdf.compress]] | zlib/DEFLATE-Kompression für PDF-Streams (intern genutzt) |
| [[lyx_-_programmiersprache:units:pdf:image|std.pdf.image]] | Rasterbilder: ''PdfAddImage'' (JPEG/RGB), ''PdfDrawImage'' mit Positionierung |
| [[lyx_-_programmiersprache:units:pdf:meta|std.pdf.meta]] | Dokument-Metadaten: Titel, Autor, Thema, Schlüsselwörter, Erstellungsdatum |
| [[lyx_-_programmiersprache:units:pdf:annot|std.pdf.annot]] | Annotationen: URI-Links, GoTo-Links, Text-Notizen |
| [[lyx_-_programmiersprache:units:pdf:reader|std.pdf.reader]] | PDF-Lesen: ''PdfOpen'', Seitenanzahl, Metadaten-Extraktion |
| [[lyx_-_programmiersprache:units:pdf:outline|std.pdf.outline]] | Outlines (Lesezeichen): ''PdfOutlineAdd'', verschachtelte Hierarchie |
| [[lyx_-_programmiersprache:units:pdf:pagelabels|std.pdf.pagelabels]] | Seitenbeschriftung: römisch, dezimal, alphabetisch |
| [[lyx_-_programmiersprache:units:pdf:transition|std.pdf.transition]] | Seitenübergänge: Dissolve, Wipe, Push, Split (Präsentation) |
| [[lyx_-_programmiersprache:units:pdf:viewprefs|std.pdf.viewprefs]] | Viewer-Einstellungen: Toolbar ausblenden, Vollbild, Öffnungs-Action |
| [[lyx_-_programmiersprache:units:pdf:namedest|std.pdf.namedest]] | Benannte Sprungziele für interne Links und Outline-Verweise |
| [[lyx_-_programmiersprache:units:pdf:attach|std.pdf.attach]] | Eingebettete Dateianhänge: ''PdfAttachFile'' |
| [[lyx_-_programmiersprache:units:pdf:layer|std.pdf.layer]] | Optional-Content-Groups (Layer/OCG): sichtbare/ausblendbare Ebenen |

<code lyx>
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");
}
</code>

-----

===== LFD-Binärformat =====

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

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:lfd_parser|std.lfd_parser]] | LFD-Binärdateien lesen: ''LfdOpen'', ''LfdReadRecord'', Feld-Iteration |
| [[lyx_-_programmiersprache:units:lfd_factory|std.lfd_factory]] | LFD-Binärdateien schreiben: ''LfdCreate'', ''LfdWriteRecord'', ''LfdClose'' |

-----

===== SVG-Bibliothek =====

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: [[lyx_-_programmiersprache:units:svg|std.svg Übersicht]]

<code lyx>
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);
</code>

^ Unit ^ Gruppe ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:svg|std.svg]] | API | Öffentliche Einstiegs-API: SvgNew, SvgSave, SvgFree, SvgToString |
| [[lyx_-_programmiersprache:units:svg:builder|std.svg.builder]] | Infrastruktur | Dokumentlebenszyklus, Gruppen (''<g>''), Viewport, viewBox |
| [[lyx_-_programmiersprache:units:svg:xml|std.svg.xml]] | Infrastruktur | Interner XML-Schreiber: Puffer, Zahlenformatierung, Escaping |
| [[lyx_-_programmiersprache:units:svg:style|std.svg.style]] | Querschnitt | Fill, Stroke, Opacity, Transforms, Dash-Muster, Farb-Utilities |
| [[lyx_-_programmiersprache:units:svg:elements|std.svg.elements]] | Inhalt | Grundformen: rect, circle, ellipse, line, polyline, polygon |
| [[lyx_-_programmiersprache:units:svg:path|std.svg.path]] | Inhalt | Pfad-Builder: moveTo, lineTo, Bezier-Kurven, Bögen, close |
| [[lyx_-_programmiersprache:units:svg:text|std.svg.text]] | Inhalt | Text: SvgTextAt, tspan, Text auf Pfad, Rotation, Font-Styling |
| [[lyx_-_programmiersprache:units:svg:defs|std.svg.defs]] | Inhalt | Definitionen: Farbverläufe, Muster, Symbole, Marker, Clips |
| [[lyx_-_programmiersprache:units:svg:filter|std.svg.filter]] | Inhalt | Filter: Gaussian Blur, Schlagschatten, Graustufen, feComposite |
| [[lyx_-_programmiersprache:units:svg:image|std.svg.image]] | Inhalt | Bilder: JPEG/PNG einbetten, Base64-URI, RGB→PNG-Konvertierung |
| [[lyx_-_programmiersprache:units:svg:anim|std.svg.anim]] | Inhalt | SMIL-Animation: animate, animateTransform, Keyframes, animateMotion |
| [[lyx_-_programmiersprache:units:svg:parser|std.svg.parser]] | Lesen | SVG-Reader: SvgOpen, DOM-Traversierung, SvgAttrStr, SvgFindById |

-----

===== Android =====

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.

^ Unit ^ Beschreibung ^
| [[lyx_-_programmiersprache:units:android:apk_builder|std.android.apk_builder]] | APK-Builder: PKZIP-Archive für Android-Pakete zusammenstellen |
| [[lyx_-_programmiersprache:units:android:app_glue|std.android.app_glue]] | ''NativeActivity''-Worker-Thread-Glue-Schicht (android_app-Struktur) |
| [[lyx_-_programmiersprache:units:android:asset|std.android.asset]] | NDK-Asset-Manager: Typen und Konstanten für ''AAssetManager'' |
| [[lyx_-_programmiersprache:units:android:gles2|std.android.gles2]] | OpenGL ES 2.0 Core-Bindings: Shader, Texturen, Framebuffer |
| [[lyx_-_programmiersprache:units:android:input|std.android.input]] | NDK-Eingabe-Events: Typen und Konstanten für ''AInputEvent'' |
| [[lyx_-_programmiersprache:units:android:ioctl|std.android.ioctl]] | ioctl-Nummernkatalog für ASHMEM, ALSA und V4L2 |
| [[lyx_-_programmiersprache:units:android:jni|std.android.jni]] | JNI 1.6 Typ-Aliases: ''JNIEnv'', ''JavaVM'', ''jclass'', ''jobject'' |
| [[lyx_-_programmiersprache:units:android:log|std.android.log]] | Logcat-Logging: Ausgabe auf stderr/fd 2 mit Priority-Level |
| [[lyx_-_programmiersprache:units:android:looper|std.android.looper]] | ''ALooper''-Ereignis-Dispatch-Primitiv für native Event-Loops |
| [[lyx_-_programmiersprache:units:android:manifest_gen|std.android.manifest_gen]] | ''AndroidManifest.xml''-Generator für native Activities |
| [[lyx_-_programmiersprache:units:android:native_activity|std.android.native_activity]] | ''ANativeActivity''-Struct und Callback-Tabelle |
| [[lyx_-_programmiersprache:units:android:native_window|std.android.native_window]] | NDK-Native-Window: Typen und Pixelformat-Konstanten |
| [[lyx_-_programmiersprache:units:android:random|std.android.random]] | Kryptografische Zufallszahlen via ''/dev/urandom'' |
| [[lyx_-_programmiersprache:units:android:restrictions|std.android.restrictions]] | Katalog der unter SELinux/Bionic gesperrten Syscalls |
| [[lyx_-_programmiersprache:units:android:sensor|std.android.sensor]] | NDK-Sensor-Typen: Beschleunigungsmesser, Gyroskop, Magnetometer |
| [[lyx_-_programmiersprache:units:android:zip_writer|std.android.zip_writer]] | PKZIP-Writer für gespeicherte Einträge (Grundlage für APK-Build) |

<code lyx>
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);
}
</code>

Letzte Aktualisierung: 2026-05-23