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
| 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 |
| 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) |
| 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 |
| 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 |
| Ich will … | Unit |
|---|---|
| ZIP-Archiv lesen (stored + deflated) | std.zip (ZipOpen, ZipRead) |
| ZIP-Archiv erstellen | std.zip (ZipWriterNew, ZipWriterAdd, ZipWriterSave) |
| Einzelne Datei in ZIP suchen | std.zip (ZipFind) |
| TAR-Archiv lesen (POSIX ustar) | std.tar (TarOpen, TarRead) |
| TAR-Archiv erstellen | std.tar (TarWriterNew, TarWriterAdd, TarWriterSave) |
| .tar.gz erzeugen | std.tar + std.zlib (TarWriterSave → GzipCompress) |
| RAR5-Archiv lesen (nur stored) | std.rar (RarOpen, RarRead) |
| RAR-Archiv erstellen | nicht möglich — RARLAB-Lizenz nötig; stattdessen std.zip verwenden |
| ISO 9660-Image lesen (CD/DVD-Inhalt extrahieren) | std.iso (IsoOpen, IsoRead) |
| ISO 9660-Image erstellen | std.iso (IsoWriterNew, IsoWriterAdd, IsoWriterSave) |
| ISO 9660 vollständiger Guide | → ISO Guide |
| Rohe DEFLATE-Kompression / -Dekompression | std.zlib |
Brotli-Stream dekomprimieren (HTTP Content-Encoding: br) | std.brotli (BrotliDecompress) |
| Brotli-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | std.brotli (BrotliCompress) |
| Zstd-Stream (.zst, Kafka, Docker-Layer) dekomprimieren | std.zstd (ZstdDecompress) |
| Zstd-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | std.zstd (ZstdCompress) |
| 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 |
→ 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) |
| 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) |
| 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) |
| 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 |
| 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 |
| Ich will … | Unit |
|---|---|
| CPU-Fähigkeiten erkennen (SSE2, SSE4.1, AVX2) | std.cpu.features (CpuHasSSE2, CpuHasAVX2) |
| Besten SIMD-Pfad zur Laufzeit wählen | std.cpu.dispatch (CpuDispatchLevel) |
| 16-Byte-ausgerichtetes f32-Array anlegen | std.cpu.dispatch (SimdAlloc) |
| Elementweise f32-Addition auf Arrays | std.cpu.dispatch (SimdAdd) |
| Elementweise f32-Multiplikation auf Arrays | std.cpu.dispatch (SimdMul) |
| Einzelnes Element eines SIMD-Arrays lesen | std.cpu.dispatch (SimdGet) |
| SIMD-Array-Länge abfragen | std.cpu.dispatch (SimdLen) |
| GPU-Berechnungen (CUDA/Vulkan/OpenCL) | std.gpu.* — noch nicht implementiert (geplant WP-GPU-07–09) |
| 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 |
| 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 |
| 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 |
| Ich will … | Unit |
|---|---|
| S3-Datei hochladen / herunterladen | std.cloud.s3 |
| Große Datei (> 100 MB) nach S3 hochladen | std.cloud.s3 (S3PutObjectMultipart) |
| S3-Objekte paginiert auflisten | std.cloud.s3 (S3ListAll / S3ListObjectsNext) |
| S3-Teilbereich herunterladen (Range) | std.cloud.s3 (S3GetObjectRange) |
| S3-Presigned GET-URL (Download-Link) | std.cloud.s3 (S3PresignGet) |
| S3-Presigned PUT-URL (Client-Upload ohne Credentials) | std.cloud.s3 (S3PresignPut) |
| Cloudflare R2 via S3-API | std.cloud.s3 (S3ConnectR2) |
| MinIO (Self-Hosted S3) | std.cloud.s3 (S3ConnectMinio) |
| EC2-Instanz starten / stoppen | std.cloud.ec2 |
| DynamoDB-Item lesen / schreiben | std.cloud.dynamodb |
| Lambda-Funktion aufrufen | std.cloud.lambda (LambdaInvoke) |
| SQS-Nachricht senden / empfangen | std.cloud.sqs |
| SNS-Topic-Nachricht / SMS versenden | std.cloud.sns |
| CloudWatch-Metriken schreiben | std.cloud.cloudwatch (CWPutMetricData) |
| AWS-Secret auslesen | std.cloud.secrets (SecretsGetString) |
| SSM-Parameter lesen | std.cloud.secrets (SSMGetParameterValue) |
| IAM-Rolle annehmen (STS AssumeRole) | std.cloud.iam (STSAssumeRole) |
| AWS-Credentials aus Umgebung / Datei laden | std.cloud.aws.core (AWSCredentialsDefault) |
| DigitalOcean Droplet erstellen | std.cloud.do.droplets (DropletCreateSimple) |
| DO Block-Storage Volume anhängen | std.cloud.do.volumes (VolumeAttach) |
| DO Spaces (S3-kompatibler Speicher) nutzen | std.cloud.do.spaces |
| DO Managed Database anlegen | std.cloud.do.databases (DatabaseCreate) |
| DO Kubernetes-Cluster anlegen / Kubeconfig | std.cloud.do.kubernetes (K8sClusterCreate, K8sKubeconfig) |
| DO App Platform deployen | std.cloud.do.apps (AppCreateFromSpec) |
| DO Serverless Function aufrufen | std.cloud.do.functions (FunctionInvoke) |
| DO DNS-Record anlegen / aktualisieren | std.cloud.do.networking (DomainRecordCreate) |
| DO Load Balancer erstellen | std.cloud.do.networking (LBCreate) |
| DO Container Registry nutzen | std.cloud.do.registry |
| DO-Credentials aus Umgebung laden | std.cloud.do.credentials (DOCredentialsFromEnv) |
| Cloud-Übersicht (AWS + DO) | → std.cloud |
| S3 vollständiger Guide (Upload, Multipart, Presigned, Listing) | → S3-Guide |
| Cloud vollständiger Guide | → Cloud-Guide |
| Cloudflare DNS-Record setzen | std.cloud.cf.dns (DNSRecordUpsert) |
| Cloudflare Worker deployen | std.cloud.cf.workers (WorkerDeploy) |
| Cloudflare KV-Store lesen / schreiben | std.cloud.cf.kv (KVGet / KVPutWithTTL) |
| R2-Objekt hochladen (Cloudflare) | std.cloud.cf.r2 (R2Upload) |
| D1-SQLite-Datenbank abfragen (Cloudflare) | std.cloud.cf.d1 (D1Query) |
| Zone-Cache leeren (Cloudflare) | std.cloud.cf.cache (CachePurgeAll) |
| IP-Adresse sperren / WAF-Regel (Cloudflare) | std.cloud.cf.waf (FirewallBlockIP) |
| Cloudflare Pages deployen | std.cloud.cf.pages (PagesDeployDir) |
| Tunnel ohne offenen Port (Cloudflare) | std.cloud.cf.tunnel (TunnelCreate) |
| Cloudflare-Credentials laden | std.cloud.cf.credentials (CFCredentialsFromEnv) |
| Cloudflare-Übersicht (alle CF-Units) | → std.cloud.cf |
| Ich will … | Unit |
|---|---|
| GCS-Datei hochladen | std.cloud.gcp.storage (GCSUpload) |
| GCS-Datei herunterladen | std.cloud.gcp.storage (GCSDownload) |
| GCS-Bucket anlegen | std.cloud.gcp.storage (GCSBucketCreate) |
| GCS-Objekte auflisten | std.cloud.gcp.storage (GCSList) |
| GCE-VM anlegen / starten / stoppen | std.cloud.gcp.compute (GCEInstanceCreate / GCEInstanceStart) |
| Auf asynchrone GCE-Operation warten | std.cloud.gcp.compute (GCEOperationWait) |
| Firestore-Dokument schreiben / lesen | std.cloud.gcp.firestore (FSCreate / FSGet) |
| Firestore-Collection auflisten | std.cloud.gcp.firestore (FSList) |
| Pub/Sub-Nachricht publishen | std.cloud.gcp.pubsub (PubSubPublish) |
| Pub/Sub-Nachrichten abrufen und bestätigen | std.cloud.gcp.pubsub (PubSubPull / PubSubAck) |
| Cloud Function deployen | std.cloud.gcp.functions (GCFDeploy) |
| Cloud Function aufrufen | std.cloud.gcp.functions (GCFInvoke) |
| Cloud Run Services auflisten | std.cloud.gcp.functions (GCRServiceList) |
| Log-Eintrag in Cloud Logging schreiben | std.cloud.gcp.logging (LogWrite / LogWriteJSON) |
| Custom Metric in Cloud Monitoring schreiben | std.cloud.gcp.logging (MonWriteMetric) |
| GCP-Secret auslesen | std.cloud.gcp.secrets (SecretGet) |
| GCP-Secret anlegen | std.cloud.gcp.secrets (SecretCreate) |
| IAM Service Account anlegen | std.cloud.gcp.secrets (IAMCreateServiceAccount) |
| GCP-Credentials aus Service-Account-JSON laden | std.cloud.gcp.credentials (GCPCredentialsFromFile) |
| GCP Application Default Credentials laden | std.cloud.gcp.credentials (GCPCredentialsDefault) |
| GCP-Übersicht (alle GCP-Units) | → std.cloud.gcp |
| Ich will … | Unit |
|---|---|
| Eine neue Transaktion erstellen und signieren | std.blockchain (BLNewTransaction, BLSignTransaction) |
| Eine Transaktion verifizieren | std.blockchain (BLVerifyTransaction) |
| Eine Coinbase-Transaktion erstellen (Mining-Belohnung) | std.blockchain (BLNewCoinbaseTx) |
| Einen neuen Block erstellen | std.blockchain (BLNewBlock, BLCalculateHash, BLMeetsTarget) |
| Einen Block minen (PoW) | std.blockchain (BLMinePendingTransactions) |
| TX zum Mempool hinzufügen | std.blockchain (BLAddTransaction) |
| Kontostand einer Adresse abfragen | std.blockchain (BLBlockchainGetBalance) |
| Ledger-Zustand direkt lesen | std.blockchain (BLGetBalance, BLGetNonce) |
| Gesamte Kette auf Gültigkeit prüfen | std.blockchain (BLIsValidChain) |
| Merkle-Root berechnen | std.blockchain (BLMerkleRoot) |
| Big-Endian-Serialisierung für Blockchain-Daten | std.blockchain (BLSerializeInt32, BLSerializeInt64) |
| P2P-Knoten starten und Peers verbinden | std.blockchain.p2p (BLP2PNodeNew, BLP2PNodeStart, BLP2PConnectPeer) |
| Transaktion an alle Peers broadcasten | std.blockchain.p2p (BLP2PBroadcastTx) |
| Block an alle Peers broadcasten | std.blockchain.p2p (BLP2PBroadcastBlock) |
| Eingehende P2P-Nachricht verarbeiten | std.blockchain.p2p (BLP2PHandleIncoming) |
| Neue Peer-Verbindung akzeptieren | std.blockchain.p2p (BLP2PPoll) |
| Blockchain-Übersicht (alle Units) | → std.blockchain |
| Blockchain-Guide (Workflows, P2P, Speicherverwaltung) | → Blockchain-Guide |
| Ich will … | Unit |
|---|---|
| Kassenbon TSE-signieren (einfach, einstufig) | kassensichv.manager (TseProcessBeleg) |
| Tischbewirtung / mehrstufigen Vorgang signieren | kassensichv.manager (TseOpenBeleg → TseCloseBeleg) |
| QR-Code-String nach BSI TR-03153 erzeugen | automatisch durch TseProcessBeleg / TseCloseBeleg in SigErgebnis.qrCode |
| BelegDaten-Typ und Prozesstyp-Konstanten | kassensichv.types |
| TSE-Anbindung ohne Hardware testen (CI/CD) | kassensichv.mock (TseMockNew, Fehlersimulation) |
| Cloud-TSE anschließen (Fiskaly, Deutsche Fiskal) | kassensichv.rest (TseRestNew, JSON-Config) |
| USB-TSE anschließen (Swissbit, Epson) | kassensichv.file (TseFileNew, base_path) |
| DSFinV-K-Export für Finanzamt-Prüfung | kassensichv.manager (TseExportAuditData) |
| TSE-Fehler behandeln, offene Transaktionen erkennen | kassensichv.exceptions |
| KassenSichV-Übersicht (alle Units) | → kassensichv |
| KassenSichV-Guide (Workflows, Checkliste, Entscheidungsguide) | → KassenSichV-Guide |
std.net.https statt std.net.tls + std.net.http manuell kombinieren — es sei denn, man braucht Kontrolle über den TLS-Handshake.PdfSetConformance → PdfGenerateXMP → PdfSave.std.net.epoll für > 100 gleichzeitige Verbindungen; std.net.socket (Poll) für kleinere Server.redis_simple hat keine Abhängigkeit auf std.string — nützlich für extrem kleine Binaries oder Embedded-Targets.Letzte Aktualisierung: 2026-06-13 (GCP, Blockchain und CPU/SIMD ergänzt)