Nyx by Example

English

The best way to learn a language is to read real code. This collection of short, focused examples walks you through Nyx one concept at a time. Each recipe is self-contained: you can copy it, run it, and modify it to explore further.

No prior experience with Nyx is required. If you can read code in any C-like language, you will feel at home immediately.

Español

La mejor forma de aprender un lenguaje es leer código real. Esta colección de ejemplos cortos y enfocados recorre Nyx concepto por concepto. Cada receta es autocontenida: puedes copiarla, ejecutarla y modificarla para explorar más.

No se requiere experiencia previa con Nyx. Si puedes leer código en cualquier lenguaje similar a C, te sentirás en casa de inmediato.

Fundamentals

The simplest Nyx program — printing text to the terminal.

Immutable let, mutable var, basic types, and string interpolation.

Defining functions with parameters, return types, and default arguments.

if/else, while loops, for-range, for-in, break and continue.

Creating, indexing, pushing, and iterating over dynamic arrays.

Key-value storage with Map.new(), insert, get, has, and key iteration.

trim, length, substring, toUpper, split, contains, and interpolation.

Defining data types with fields and attaching methods via impl.

Algebraic data types with data-carrying variants and exhaustive match.

First-class functions that capture their enclosing environment.

I/O & Data

File Read & Write

Reading and writing files with read_file and write_file.

Reading user input from the terminal with read_line.

Accessing command-line arguments with get_args.

Environment Variables

Reading env vars with getenv and getenv_default.

Parsing JSON strings into Maps and Arrays.

Converting data structures back to JSON strings.

Regular Expressions

Match, extract, and replace with POSIX regex.

Splitting lines and fields to process tabular data.

Timestamps, formatted dates, and time measurement.

Threads & Channels

Spawning threads and communicating via channels.

Types & Patterns

Defining shared behavior with trait and impl ... for.

Constraining generics with <T: Display>.

Auto-generating Clone, Debug, and other trait impls.

Handling optional values with Some and None.

Error handling with Ok and Err.

Short-circuit error propagation with ?.

Destructuring enums in conditions with if let.

Adding conditions to match arms with if guards.

Iterator: Map & Filter

Lazy transformations with .iter().filter().map().collect().

Reducing a sequence to a single value with fold.

Advanced

Iterator: Enumerate

Getting index and value pairs during iteration.

Iterator: Take & Skip

Slicing sequences with take and skip.

Solving problems with functions that call themselves.

Sorting arrays of integers and strings.

try/catch blocks for recovering from runtime errors.

Guaranteed cleanup with defer { ... } blocks.

Pausing execution and measuring elapsed time.

Crypto: Hashing

SHA-256, MD5, and HMAC-SHA256 for integrity checking.

Generating random numbers and unique identifiers.

Running functions concurrently with thread_spawn.

Networking & Protocols

RFC 4648 encoding/decoding — standard and URL-safe variants.

Percent-encoding, query strings, and HTML entity escaping.

Parsing configuration strings with std/toml.

Binary serialization — ~30% smaller than JSON.

Converting hostnames to IP addresses with resolve.

Connecting, writing, and reading over raw TCP sockets.

Listening, accepting, and echoing with tcp_listen.

Connectionless datagrams with udp_bind and udp_sendto.

High-level HTTP client requests with std/http.

POST requests and custom methods with http_request.

Minimal server with http_serve and request routing.

HTTP Middleware

Web framework with App, routes, logging, and CORS.

RFC 6455 framing, parsing, and handshake responses.

Building Redis wire-format messages manually.

In-memory SQL database with sqlite_open and sqlite_query.

Creating and serializing CSV documents with std/csv.

Concurrency

Protecting shared state between threads with locks.

Channel Patterns

Message passing with buffered channels and sentinels.

Dispatching tasks to N threads via shared channels.

Producer-Consumer

Decoupled pipeline with bounded-channel backpressure.

Waiting for multiple threads with wg_add/wg_done/wg_wait.

Limiting concurrent access with sem_acquire/sem_release.

Multiplexing channels with the select statement.

Systems

Running external commands with fork, execvp, and waitpid.

Connecting processes with pipe_new and dup2.

Signal Handling

Registering signal callbacks with signal_handle.

Detecting file changes by polling with stat.

Process Control

PID, working directory, terminal detection, and file stat.

Character-by-character input with raw_mode_enter.

Running Nyx files as executable scripts with #!/usr/bin/env nyx.

nyx-kv (Key-Value Store)

Connect to nyx-kv and issue SET/GET/DEL commands over RESP.

RPUSH, LPOP, LRANGE, LLEN for FIFO queues and stacks.

HSET/HGET/HLEN for structured data like user profiles.

Multi-tenant authentication with tokens and namespaces.

Real-time messaging with SUBSCRIBE and PUBLISH.

TTL with EXPIRE, PERSIST, and SET EX for cache and sessions.

Batch commands for 250K+ ops/sec throughput.

nyx-serve (Web Framework)

RESTful routing with GET/POST/PUT/DELETE and path params.

Parse request bodies and build JSON responses with helpers.

Serve CSS, JS, and images with app_static and MIME detection.

Cookie-based sessions backed by nyx-kv with TTL.

http_serve_mt with N worker threads for 73K req/s.

Cross-origin headers with mw_cors and cors_configure.

HTTP server + JSON API + nyx-kv backend in one binary.

nyx-proxy (Reverse Proxy)

Parse proxy.toml with std/toml.

Route by Host header to different upstreams.

TCP probe upstreams with threshold and auto-recovery.

Per-IP sliding window returning HTTP 429 when exceeded.

Multi-domain HTTPS on one port with Let's Encrypt certs.

Queue, DB & HTTP/2

Persistent message queue with ENQUEUE and QLEN.

DEQUEUE + ACK/NACK loop with automatic redelivery.

CREATE/INSERT/SELECT over nyx-db RESP protocol.

DB Transactions

BEGIN/COMMIT/ROLLBACK for atomic operations.

Stream multiplexing and HPACK header compression.

Binary frame types: DATA, HEADERS, SETTINGS, PING.

Full-stack Patterns

Complete CRUD API with middleware and nyx-kv backend.

Real-time Pub/Sub

WebSocket + nyx-kv Pub/Sub for live updates.

Queue consumer with cache-aside pattern via nyx-kv.

Rate-limited API

Atomic INCR + EXPIRE for per-user rate limits.

Production Stack

Full nyxlang.com architecture: proxy + web + kv + queue.