Welche Unit brauche ich?

Task-orientierter Wegweiser durch die Standardbibliothek. Ausgangspunkt ist immer die konkrete Aufgabe — nicht der Namespace. Jede Zeile verweist auf die präziseste Unit; Links direkt zur Detailseite.

→ Alle Units alphabetisch · Erste Schritte

Netzwerk & Kommunikation

Ich will …	Unit
TCP-Verbindung aufbauen (Client)	`std.net.socket`
TCP-Server bauen (wenige Verbindungen)	`std.net.socket`
TCP-Server bauen (1 000+ gleichzeitige Verbindungen)	`std.net.epoll` + `std.net.socket`
HTTP-Request (GET/POST) absetzen	`std.net.http`
HTTPS-Request absetzen	`std.net.https`
TLS-Verbindung manuell aufbauen	`std.net.tls`
Domain-Name auflösen (DNS)	`std.net.dns`
E-Mail versenden (SMTP)	`std.net.smtp`
E-Mails abrufen (IMAP)	`std.net.imap`
SSH-Befehl remote ausführen	`std.net.ssh`
IoT-Gerät via MQTT anbinden	`std.net.mqtt`
Zeit per NTP synchronisieren	`std.net.ntp`
WHOIS-Abfrage für Domain oder IP	`std.net.whois`
LDAP / Active Directory abfragen	`std.net.ldap`
Netzwerk-Gerät per SNMP auslesen	`std.net.snmp`
VoIP / SIP-Signaling	`std.net.sip`
UDP-Socket direkt verwenden	`std.net.socket`
Ereignis-fd für Thread-Wakeup	`std.net.epoll` (`EventFdCreate`)
Android-Netzwerk-Syscalls	`std.net.internal.syscalls_android`

Datenbanken

Ich will …	Unit
MySQL oder MariaDB abfragen	`std.db.mysql`
PostgreSQL abfragen (ohne libpq)	`std.db.postgres`
Embedded-DB / Single-File / Mobile	`std.db.sqlite`
In-Memory-Datenbank (SQLite)	`std.db.sqlite` (`SQLiteOpen(„:memory:“)`)
Sessions oder Caching speichern	`std.db.redis`
Pub/Sub zwischen Prozessen	`std.db.redis`
Redis ohne std.string-Abhängigkeit	`std.db.redis_simple`
JSON-Dokumente speichern	`std.net.mongo`
PostgreSQL Connection Pooling	`std.db.postgres` (`PGPoolCreate`)
Bulk-Import (tausende Rows schnell)	`std.db.postgres` (COPY) · `std.db.sqlite` (Transaktion)

PDF erstellen

Ich will …	Unit
Einfaches PDF mit Text und Linien	`std.pdf.builder` + `std.pdf.graphics`
Schriftart auswählen (Helvetica, Times …)	`std.pdf.fonts`
Umlaute / Unicode-Text einbetten	`std.pdf.ttfont` (TrueType + Subsetting)
Rasterbilder einfügen (JPEG/PNG)	`std.pdf.image`
Farbverlauf (linear oder radial)	`std.pdf.shading`
PANTONE / Sonderfarbe verwenden	`std.pdf.spot`
Grafik-Block mehrfach wiederverwenden	`std.pdf.xobject`
Interaktives Formular erstellen	`std.pdf.forms`
Formular-Felder einfrieren (flatten)	`std.pdf.forms` (`PdfFlattenForms`)
Lesezeichen (Outline/Bookmarks)	`std.pdf.outline`
Hyperlinks und Annotationen	`std.pdf.annot`
Dokument-Metadaten (Titel, Autor)	`std.pdf.meta`
XMP-Metadaten einbetten	`std.pdf.xmp`
PDF/A (Langzeitarchivierung)	`std.pdf.pdfa` + `std.pdf.xmp`
ZUGFeRD / Factur-X Rechnung	`std.pdf.pdfa` (A-3b) + `std.pdf.attach`
Layer (ein-/ausblendbare Ebenen)	`std.pdf.layer`
Seitenübergänge (Präsentation)	`std.pdf.transition`
Vorhandenes PDF öffnen / analysieren	`std.pdf.reader`

Dateisystem & I/O

Ich will …	Unit
Datei öffnen, lesen, schreiben, schließen	`std.fs`
Datei-Metadaten lesen (fstat, Größe)	`std.fs_ext`
Scatter/Gather-I/O (readv/writev)	`std.fs_ext`
Positional-I/O (pread/pwrite)	`std.fs_ext`
Datei direkt zu Socket senden (sendfile)	`std.fs_ext`
Verzeichnisinhalt auflisten (DirList)	`std.fs` (`DirList` / `DirEntryName` / `DirEntryTypeAt`)
Verzeichnis rekursiv traversieren	`std.fs` (`DirWalk`)
Dateien nach Wildcard suchen (*.log)	`std.fs` (`FileGlob`)
Einmalige Temp-Datei anlegen	`std.fs` (`TmpFile()`)
Erweitertes Attribut (xattr) lesen/schreiben	`std.xattr`
Freien Speicher eines Dateisystems abfragen	`std.xattr` (`StatFsFreeBytes`)
Speicherplatz für Datei vorab reservieren	`std.xattr` (`FileAllocate`)
Asynchrones I/O (viele gleichzeitige Ops)	`std.io_uring`
Dateisystem-Änderungen überwachen	`std.inotify`
Pipe zwischen Prozessen	`std.pipe`
Dateideskriptor duplizieren (dup/dup2)	`std.pipe`
Anonyme In-Memory-Datei (memfd)	`std.mmap_ext`
Shared Memory (mmap + ftruncate)	`std.mmap_ext`
Mapping wachsen lassen (mremap)	`std.mmap_ext`
Seiten im RAM fixieren (mlock)	`std.mmap_ext`
IPC Message Queues (POSIX mq)	`std.mqueue`

Strings & Datenformate

Ich will …	Unit
Strings suchen, ersetzen, trimmen	`std.string`
String mit Platzhaltern formatieren (%s/%d/%x)	`std.string` (`StrFormat`)
Regex-Matching und -Suche	`std.regex`
JSON lesen oder schreiben	`std.json`
XML parsen oder erzeugen	`std.xml`
YAML-Konfiguration laden	`std.yaml`
INI-Konfigurationsdatei einlesen	`std.ini`
URL parsen (Schema, Host, Query)	`std.url`
URL aus Teilen zusammenbauen	`std.url` (`URLBuild`)
Query-Parameter lesen oder setzen	`std.url` (`URLQueryGet` / `URLQuerySet`)
Relativen URL gegen Basis auflösen	`std.url` (`URLResolve`)
Percent-Encoding / -Decoding (RFC 3986)	`std.url` (`URLPercentEncode` / `URLPercentDecode`)
Base64 kodieren/dekodieren	`std.base64`
HTML escapen / Tags entfernen	`std.html`
Binär serialisieren (VarInt, Pack)	`std.pack`
Struct-Feld auf exaktes Byte-Offset legen (Protokoll-Header)	`@at(N)`
Mehrbyte-Feld als Big-Endian / Network Byte Order markieren	`@big_endian`
Daten komprimieren (zlib/DEFLATE)	`std.zlib`
Hex/Binär/Oktal-Konvertierung	`std.conv`

Kryptografie & Sicherheit

→ Kryptographie-Guide: Vergleich aller Units, Empfehlungen, Entscheidungsguide

Ich will …	Unit
Daten mit AES-128/256 verschlüsseln	`std.crypto.aes`
MD5-Hash (Checksum / Protokoll)	`std.crypto.md5`
SHA-1-Hash (Git-Objekte, MySQL-Auth)	`std.crypto.sha1`
SHA-256-Hash (FIPS 180-4, one-shot)	`std.crypto.sha256`
HMAC-SHA256 (Nachrichten-Authentifizierung)	`std.crypto.hmac`
ECDSA-Signatur erzeugen / prüfen (secp256k1)	`std.crypto.ecc`
Kryptografisch sichere Zufallsbytes	`std.crypto.rand` (`RandBytesExact`)
Sicheren Zufalls-int64 erzeugen	`std.crypto.rand` (`RandInt64` — 0 bei Fehler; für sicherheitskritischen Code `RandBytesExact` bevorzugen)
Passwort sicher hashen (bcrypt/Argon2)	`std.hash`
TLS/HTTPS-Verbindung aufbauen	`std.net.tls`
Binary-Integrität zur Laufzeit prüfen	`std.meta_safe`
UUID zufällig oder zeitbasiert erzeugen	`std.uuid`
Symmetrisch authentifiziert verschlüsseln (Latin-Square, 128-Bit Quantensicherheit)	`std.crypto.pqc.dadq` → `dadqFOEnc` / `dadqFODec` (FO-Modus empfohlen)
DADQ-Schlüssel für PKE kapseln (Hybrid)	`std.crypto.pqc.dadq` + `std.crypto.pqc.mlkem`: ML-KEM kapselt den 32-Byte master_seed
Post-Quantum-Schlüsselaustausch (ersetzt ECDH)	`std.crypto.pqc.pqc` → `PQCKeyGen(PQC_ALG_MLKEM_768)`
Post-Quantum-Schlüsselaustausch + klassisch (Signal/Apple-Schema)	`std.crypto.pqc.pqc` → `PQCKeyGen(PQC_ALG_HYBRID_768)`
Post-Quantum-Signatur (ersetzt ECDSA)	`std.crypto.pqc.pqc` → `PQCKeyGen(PQC_ALG_MLDSA_65)`
Post-Quantum-Signatur (nur SHA-256-Annahmen, kleiner PK)	`std.crypto.pqc.pqc` → `PQCKeyGen(PQC_ALG_SLHDSA_128S)`

Prozesse, Threads & IPC

Ich will …	Unit
Neuen Prozess starten (fork/exec)	`std.process`
Shell-Befehl ausführen + Ausgabe lesen	`std.process` (`Shell`)
POSIX-Threads anlegen	`std.thread`
Mutex / Bedingungsvariablen	`std.thread`
Signale abfangen (SIGTERM, SIGUSR1 …)	`std.signals`
Signal als fd lesen (signalfd)	`std.signals`
CPU-Affinität setzen (CPU-Pinning)	`std.sched`
Nice-Wert / Prozess-Priorität ändern	`std.sched`
UID/GID lesen, Root prüfen	`std.process_ext`
Session / Prozessgruppe wechseln	`std.process_ext`
Systeminformationen (/proc) auslesen	`std.systeminfo`
IPC über POSIX Message Queues	`std.mqueue`
IPC über Pipes	`std.pipe`
SysV Shared Memory (shmget/shmat)	`std.ipc_sysv` (`ShmCreate` / `ShmAttach`)
SysV Semaphore (P/V-Operationen)	`std.ipc_sysv` (`SemCreate` / `SemWait` / `SemPost`)
SysV Message Queue	`std.ipc_sysv` (`MsgQueueCreate` / `MsgSend` / `MsgRecv`)
Signal race-frei an Prozess senden (pidfd)	`std.ns` (`PidFdOpen` / `PidFdSendSignal`)

System & Kernel

Ich will …	Unit
Asynchrones I/O (io_uring, Kernel 5.1+)	`std.io_uring`
SysV IPC (Shared Memory, Semaphore, Queues)	`std.ipc_sysv`
eBPF-Programm laden und Maps verwalten	`std.bpf` (braucht CAP_BPF oder CAP_SYS_ADMIN)
Prozess per ptrace debuggen / tracen	`std.debug` (`PtraceAttach` / `PtraceGetRegs`)
Hardware-Performance-Counter auslesen	`std.debug` (`PerfEventOpen` / `PerfCount`)
Linux-Namespaces wechseln / trennen	`std.ns` (`NamespaceUnshare` / `NamespaceJoin`)
Process-Capabilities lesen / abgeben	`std.security_ext` (`CapGet` / `CapDrop`)
PR_SET_NO_NEW_PRIVS setzen (irreversibel)	`std.security_ext` (`ProcessSetNoNewPrivs`)
Prozessname setzen (prctl PR_SET_NAME)	`std.security_ext` (`ProcessSetName`)
Dateisystem mounten / unmounten	`std.sysadmin` (`Mount` / `Umount`)
Root-Verzeichnis wechseln (chroot)	`std.sysadmin` (`Chroot`)
Hostnamen setzen	`std.sysadmin` (`SetHostname`)
System-Reboot / Poweroff auslösen	`std.sysadmin` (`Reboot`)

Ausgabe & Benutzeroberflächen

Ich will …	Unit
Text und Zahlen ausgeben	`std.io`
Terminal mit ANSI-Farben und Cursor	`std.crt`
Einzelne Zeichen non-blocking lesen	`std.crt_raw`
Vollständige TUI (Fenster, Dialoge, Menüs)	`LyxVision`
LyxVision vollständiger Guide	→ LyxVision-Guide
Desktop-GUI-Fenster mit Qt5	`std.qt5_app`
OpenGL in Qt5-Fenster	`std.qt5_gl`
Strukturiertes Logging (5 Level)	`std.log`
JSON-Logzeile mit Key-Value (log_info_kv)	`std.log` (`log_info_kv`)
SVG-Grafik programmatisch erzeugen	`std.svg`
SVG vollständiger Guide	→ SVG-Guide

Mathematik & Algorithmen

Ich will …	Unit
sin, cos, sqrt, pow, floor, round …	`std.math`
Arcustangens (atan / atan2)	`std.math` (`AtanF64` / `Atan2F64`)
Arcussinus / Arcuskosinus	`std.math` (`AsinF64` / `AcosF64`)
Binärer Logarithmus (log₂)	`std.math` (`Log2F64`)
Geometrische 2D-Vektoren (Vec2)	`std.vector`
Array sortieren	`std.sort`
Statistik (Mittelwert, Median, StdDev)	`std.stats`
GPS-Distanz / Haversine	`std.geo`
Farben (RGBA, HSL, Blend)	`std.color`
Lineare Regression, KNN, K-Means	`std.ml`
Wort-Embeddings (FastText)	`std.fasttext`

Validierung

Ich will …	Unit
IBAN validieren	`std.validate.iban`
Kreditkartennummer prüfen (Luhn)	`std.validate.luhn`
EAN-8/13-Barcode prüfen	`std.validate.ean`
ISBN-10/13 prüfen	`std.validate.isbn`
EU-Umsatzsteuer-ID prüfen	`std.validate.vat`
VIN / Fahrzeugidentifikationsnummer	`std.validate.vin`
ISIN (Wertpapierkennung)	`std.validate.isin`
Deutsche Steuer-ID / RVNR	`std.validate.de_personal`
Alle Validierungen → Übersicht	`std.validate`
Validierung vollständiger Guide	→ Validierungs-Guide

Audio & Hardware

Ich will …	Unit
WAV-Datei laden oder schreiben	`std.audio`
WAV-Datei abspielen (einfach)	`std.audio.playback`
PCM direkt per ALSA ausgeben	`std.audio.alsa`
MP3 dekodieren	`std.audio.mpg123`
Bluetooth vollständiger Guide	→ Bluetooth-Guide
Bluetooth BLE-Gerät als GATT-Client	`std.hardware.bluetooth_gattc`
Eigenen BLE-Service anbieten (GATT-Server)	`std.hardware.bluetooth_gatts` (`GattServerRegister`)
Classic Bluetooth (RFCOMM, seriell)	`std.hardware.bluetooth_rfcomm` (`RFCommConnect` / `RFCommSend`)
Bluetooth-Gerät discovern, pairen, verbinden (BlueZ)	`std.hardware.bluetooth_dbus` (`BlueZStartDiscovery` / `BlueZConnectDevice`)
BLE-Geräte in der Umgebung scannen	`std.hardware.bluetooth_ext` (`BleScannerStart` / `BleScannerReadNext`)
BLE-Advertising (als Peripheral senden)	`std.hardware.bluetooth_ext` (`BleAdvertisementRegister`)
GATT-Characteristics typsicher verwenden	`std.hardware.bluetooth_ai` (`MakeReadableChar` / `MakeNotifiableChar`)
USB vollständiger Guide	→ USB-Guide
USB-Gerät nach VID/PID finden und öffnen	`std.hardware.usb_discovery` (`UsbFindDevice`)
USB Descriptor-Baum lesen (Config/Interface/Endpoint)	`std.hardware.usb_parse` (`UsbAllocDevice` / `UsbParseConfiguration`)
USB Device Descriptor lesen (VID/PID, Class)	`std.hardware.usb_control` (`UsbGetDeviceDescriptor`)
Interface für exklusiven Zugriff beanspruchen	`std.hardware.usb_control` (`UsbClaimInterface`)
Bulk-Daten an USB-Gerät senden	`std.hardware.usb_bulk` (`UsbBulkWrite`)
Bulk-Daten von USB-Gerät empfangen	`std.hardware.usb_bulk` (`UsbBulkRead`)
Interrupt-Transfer asynchron lesen (HID, Gamepad)	`std.hardware.usb_interrupt` (`UsbSubmitInterruptRead` / `UsbWaitForUrb`)
Kontinuierlichen HID-Stream mit URB-Pool lesen	`std.hardware.usb_urb_pool` (`UsbUrbPoolInit` / `UsbUrbPoolPoll`)
Audio/Video per Isochronous Transfer streamen	`std.hardware.usb_iso` (`UsbSubmitIsoRead` / `UsbReapIsoUrb`)
Endpoint-Richtung typsicher absichern	`std.hardware.usb_endpoint_types` (`UsbMakeBulkOut` / `UsbMakeBulkIn`)
Endpoint-Adresse einmalig binden und per Key nutzen	`std.hardware.usb_endpoint_bind` (`UsbDefOutEndpoint` / `UsbEpWrite`)
Interface-Claim idempotent verwalten	`std.hardware.usb_ifc_mgr` (`UsbIfcAcquire` / `UsbIfcRelease`)
Übersicht aller USB-Units	`std.hardware.usb`
GPIO vollständiger Guide	→ GPIO-Guide
GPIO-Pin als Ausgang schalten (LED, Relais)	`std.hardware.gpio_mmio` (`GpioWritePin`) oder `std.hardware.gpio_pin` (`GpioOutputPinWrite`)
GPIO-Pin als Eingang lesen (Taster, Sensor)	`std.hardware.gpio_pin` (`GpioInputPinRead`)
LED dimmen / Software-PWM erzeugen	`std.hardware.gpio_ext` (`GpioSoftPWM`)
Auf Flanke warten (Tasterklick, Interrupt)	`std.hardware.gpio_ext` (`GpioWaitForEdge`)
Pull-Up / Pull-Down konfigurieren	`std.hardware.gpio_mmio` (`GpioSetPullMode`)
Pin auf Alt-Funktion setzen (SPI, I2C, UART)	`std.hardware.gpio_ext` (`GpioSetAltMode`)
Mehrere Pins atomar setzen (ioctl)	`std.hardware.gpio_ioctl` (`GpioSetLineValues` mit mask-Bitmap)
GPIO-Chip-Info abfragen (Lines, Name)	`std.hardware.gpio_ioctl` (`GpioGetChipInfo`)
Präzise Mikrosekunden-Wartezeit	`std.hardware.gpio_util` (`GpioDelayMicroseconds`)
BCM2711 Register-Offsets nachschlagen	`std.hardware.rpi4` (nur Konstanten)
Übersicht aller GPIO-Units	`std.hardware.gpio`

Android

Ich will …	Unit
JNI-Typen (JNIEnv, jobject …)	`std.android.jni`
Logcat-Ausgabe	`std.android.log`
OpenGL ES 2.0	`std.android.gles2`
APK zusammenbauen	`std.android.apk_builder`
Sensoren (Beschleunigung, Gyroskop)	`std.android.sensor`
Netzwerk-Syscalls auf Android	`std.net.internal.syscalls_android`
Android vollständiger Guide	→ Android-Guide
Übersicht aller Android-Units	`std.android`

Tipps zur Unit-Auswahl

Immer die spezifischste Unit wählen: std.net.https statt std.net.tls + std.net.http manuell kombinieren — es sei denn, man braucht Kontrolle über den TLS-Handshake.
Für PDF/A: Die Reihenfolge ist wichtig: PdfSetConformance → PdfGenerateXMP → PdfSave.
Für PostgreSQL vs. SQLite: PostgreSQL wenn mehrere Prozesse gleichzeitig schreiben; SQLite wenn Single-Writer oder Embedded genügt.
epoll vs. poll/select: std.net.epoll für > 100 gleichzeitige Verbindungen; std.net.socket (Poll) für kleinere Server.
std.db.redis vs. std.db.redis_simple: redis_simple hat keine Abhängigkeit auf std.string — nützlich für extrem kleine Binaries oder Embedded-Targets.

Letzte Aktualisierung: 2026-06-07