All packages

Tiny test runner for *.spec.wren files.

Image encode + decode. PNG / JPG / BMP / WebP in, RGBA8 buffer out — `Image.decode(bytes)` feeds straight into `@hatch:gpu`'s `Device.uploadImage(image)`, and `Image.encodePng(...)` writes synthesized buffers back out. Backed by the `image` crate.

Rapier-backed physics. `World2D` and `World3D` from one import — bodies, colliders, gravity, force / impulse, position + velocity reads. Bundles rapier2d + rapier3d in a single cdylib so games never have to choose between dimensions at the package level. Wires into `@hatch:game` for a step-per-frame physics loop.

GPU primitives + 2D/3D renderers. Device, Buffer, Texture, Sampler, ShaderModule, BindGroup, RenderPipeline, CommandEncoder, RenderPass on the bottom; Camera2D/3D, Renderer2D (sprite batcher), Renderer3D (lit), Mesh, Material on top. wgpu on native, WebGPU on web — same Wren API both targets.

Window + input for any WrenLift app. winit on native, page-attached canvas on web — same `Window.create({...})` API, same `pollEvents` / `closeRequested` / `size` surface across targets. Bring-your-own canvas via `Window.attach(elementId)` on web.

General-purpose audio playback for WrenLift apps. cpal-backed output stream + a tiny mixer; WAV decoding via hound. `Audio.context()` opens the device, `Sound.load(bytes)` decodes a clip, `audio.play(sound)` schedules immediate playback against the global mixer.

Embedded SQLite. `Database.open(path)` returns a connection; prepared statements with named parameter binding, rows iterated as Maps, transactions, error handling. Backed by rusqlite (bundled libsqlite — no system dependency).

Reference plugin layout for wasm-only `@hatch:*` packages. A `Hello.greet(name)` foreign method backed by a tiny Rust cdylib — copy this directory as the starting point for your own on-demand plugin and replace the body with the real work.

Server-rendered, htmx-native web framework for Wren. Router, middleware, content-negotiated rendering via @hatch:template, HTTP/1.1 server on top of @hatch:socket.

HTTP/1.1 client with TLS, streaming bodies, and fiber-cooperative reads.

TOML parser and serializer, backed by the Rust `toml` crate.

URL parser, builder, and percent-encoder.

Filesystem path manipulation: join, split, parent, ext, normalize.

UUID v4/v5/v7 generation, parsing, and byte conversion.

Fluent + functional collection operations — map / filter / reduce / flatMap / groupBy / partition / zip / sortBy / scan / chunked / windowed / distinct and the usual suspects.

Read and write ZIP archives entirely in memory (store / deflate / zstd).

ANSI color + padding + small numeric helpers for terminal output.

TCP listeners + connections and UDP datagram sockets. Blocking and non-blocking variants suitable for fiber-cooperative schedulers.

Subprocess spawn with lifecycle, streaming IO (blocking + fiber-cooperative), and pipelines.

Level-filtered structured logger with ANSI colors.

Random numbers, sampling, shuffle — one-shot statics + seedable streams.

Jinja/Twig-style templating for HTML and XML with first-class htmx support — fragments, components, slots, conditionals, loops, response helpers.

Compiled regular expressions with capture groups, replace, and split.

Process-level primitives: platform, env vars, argv, exit, tty.

Filesystem I/O — read, write, stat, list, walk.

Signals, EventEmitter, and a cooperative Scheduler for fiber concurrency.

Content-addressable assets database with hot-reload. Two backends behind one API — filesystem-backed on native (Fs.walk + content hashes + Hatch.watchFile), manifest-driven on web (fetch + lazy reads, page ships an `assets-manifest.json`). Edit a shader / texture / config file, see registered subscribers fire.

Byte buffers plus Reader / Writer streams with fiber-cooperative `withTryFn`.

Timezone-aware DateTime value type, Duration arithmetic, RFC 3339 parse + format.

RFC 4180 CSV parser + serializer. Handles quoting, embedded newlines, header rows.

Clap-style argument parser for Wren command-line tools.

Spec coverage for the built-in ByteArray / Float32Array / Float64Array types.

AES-256-GCM authenticated encryption + Ed25519 sign/verify + CSPRNG.

Entity-component-system for Wren. `World` storage + fluent `Query.with(C).without(C)` filters, component-instance bundles for one-call spawns, typed `Resources` and `Events<T>`, deferred `Commands` for safe mid-loop mutation, hierarchy via `setParent` / `childrenOf`, `onAdd` / `onRemove` lifecycle hooks, and a `Schedule` with `before` / `after` ordering for system dispatch. Pure Wren — composes with `@hatch:game`'s frame loop, runs anywhere Wren runs.

Fluent assertion primitives for Wren test specs.

Clocks, sleep, and UTC timestamp formatting.

Vector + matrix + quaternion math — Vec2 / Vec3 / Vec4 / Mat4 / Quat, easings, and scalar helpers. Built for interactive apps and games.

JSON parser and serializer. Pure Wren, no native deps.

Game framework for Wren. `Game.run(MyGame)` and you're rendering — subclass `Game`, override `setup` / `update` / `draw`, get a window + GPU device + per-frame loop wired in. Composes with `@hatch:ecs` / `@hatch:assets` / `@hatch:audio` / `@hatch:physics` for the rest of a game. Same source drives a winit window on native and a page-attached canvas on web.

Hashes (MD5/SHA-1/SHA-256/SHA-512), HMAC, base64.