Tiny API reference

Version 26.7.0 at revision daab053ee433.

Modules

• tiny.accy: A compiler and runtime for programs over multidimensional arrays, written in Zig: a caller builds a program by calling array operations, and the package records each call and checks the shapes of its values.
• tiny.acp: A coding agent often runs as a separate program: the caller starts it, sends it a prompt, and reads back its progress and its reply.
• tiny.alloc: The package decides which allocator a program's long-lived storage comes from, and it holds the byte ceiling a caller can put in front of an allocator.
• tiny.arrange: Flexible box layout resolves nested size constraints into concrete bounding rectangles.
• tiny.bench: A microbenchmark result moves with heap and stack layout, with the cache state the run starts in, and with the resolution of the clock that times it.
• tiny.bumpalo: An allocator that hands out memory by moving one cursor and releases every allocation at once is a bump arena.
• tiny.chant: The package reads C source for numeric kernels (loops over arrays with scalar arithmetic) and turns each function it supports into compiler intermediate code that a just-in-time compiler can run.
• tiny.choir: Multi-level intermediate representation framework with extensible dialects and interned contexts.
• tiny.closure: Reproducible execution requires verifying that required dependencies exist within an admitted environment.
• tiny.content: Content-addressed storage for immutable bytes names a piece of content by what it hashes to.
• tiny.cook: A persistent, content-addressed cache for derived file trees.
• tiny.coz: A caller with a profile full of hot lines still has to guess which line is worth optimizing.
• tiny.css: A CSS cascade engine: tokenizer, selector grammar, cascade, and typed computed values, with no allocation once a sheet's storage is sealed.
• tiny.deadalloc: The heap places each allocation at a block drawn at random from its size class, a randomized heap, over an allocator the caller supplies.
• tiny.deflate: The decoder expands data compressed with DEFLATE, either bare or inside a zlib or gzip wrapper, from one input buffer into one output buffer that the caller provides.
• tiny.filigree: Text typography requires translating Unicode character sequences into positioned font glyphs while respecting complex script substitution rules.
• tiny.game: The package gives the program that hosts a game what it needs to run the game's simulation in fixed time steps.
• tiny.geometry: Collision geometry over f32: primitive shapes, closest points, intersection and sweep queries, indexed triangle meshes, and a static bounding volume hierarchy, with no allocation after a tree is built.
• tiny.gif: Animated image processing requires managing cumulative canvas state without unbounded reallocation.
• tiny.glom: Glom indexes agent transcripts for multi-word phrase matching using tokens and adjacent token pairs.
• tiny.gpalloc: GpAllocator provides a general-purpose heap over a caller-supplied std.mem.Allocator stored at init and asked for pages and large blocks, the backing allocator.
• tiny.gpu: Devices, memory, pipelines, surfaces and presentation for compiled kernels.
• tiny.gui: Interface rendering benefits from separating declarative widget hierarchies from concrete presentation surfaces.
• tiny.http: Http parses and writes HTTP/1.1 requests and responses and WebSocket frames, and routes requests to handlers.
• tiny.hypothesis: Runs tests by searching for inputs that make a test fail.
• tiny.isa: The package reads x86-64 machine code and describes the first instruction in a byte slice as a structured value, calling no allocator.
• tiny.linear: Small geometric types over f32: vectors, quaternions, matrices, and affine transforms, in strict float mode with no allocation.
• tiny.machine: A virtual machine runs a guest operating system kernel so that the same run can be produced again later, from stored state, with the result checkable against a recorded identity.
• tiny.markdown: Document syntax parsing in memory-constrained contexts requires avoiding dynamic AST construction.
• tiny.memtrace: Memtrace records where a program's memory goes: which phase allocated it, from which call site, and how much of it is still live.
• tiny.mprompt: The package lets a Zig function stop partway through, hand control back to an earlier point on the call stack, and later continue from where it stopped, with a value passed in.
• tiny.pdf: PDF parsing decodes cross-reference tables, object dictionaries, and compressed stream filters over borrowed document bytes.
• tiny.peer: Provides peer identities, network addresses, and bootstrap tickets used to find other nodes.
• tiny.pluck: Probabilistic programming evaluation and weighted model counting over binary decision diagrams.
• tiny.png: PNG raster encoding and decoding operate within caller-allocated storage.
• tiny.preserves: Two programs that exchange structured data have to agree on what a value is and when two values are the same, whichever encoding carried them.
• tiny.pretty: Pretty is a width-aware document layout and structured output package.
• tiny.profiling: Controlled performance experiments across repository workloads.
• tiny.python: A Zig program hands this package the text of a small Python program and gets back the value that program computed.
• tiny.quic: QUIC version 1 carries encrypted, numbered packets over UDP.
• tiny.reducer: Starting from an input that reproduces a defect and deleting runs of bytes from it until a smaller input still reproduces it is test-case reduction.
• tiny.reticulum: Everything one program needs to reach a named party across a mesh network: the address that names the party, the key material behind that address, the bytes that go on the wire, the ciphers that seal a payload, and the state machine that drives one node of the mesh.
• tiny.rig: Skeletons, poses, skinning and clips.
• tiny.sandbox: Executes a single command in a temporary working tree so callers can inspect filesystem changes before deciding what to retain.
• tiny.sdfii: Evaluating geometry and boundary-value problems without volumetric meshes requires continuous spatial representations.
• tiny.simd: Portable SIMD vector types and hardware-accelerated numeric kernels.
• tiny.smg: Full compiler semantic analysis requires complete build graphs, target configurations, and heavy type checking.
• tiny.smt: The package decides whether a formula over Boolean values, fixed-width bit-vectors, finite arrays and uninterpreted functions can be made true.
• tiny.sql: An embedded relational database written in Zig holds its rows in B-trees over fixed 4096-byte units of storage, called pages.
• tiny.stabilizer: Randomizes a program's memory layout by choosing heap addresses, stack frame padding, and code addresses at random (layout randomization), so that a benchmark can run over many layouts.
• tiny.stun: Stun builds and reads STUN messages, parses the type-length-value records following the message header (attributes), and verifies message integrity.
• tiny.syn: The package marks up source code for display one line at a time: for each line it records which byte ranges are keywords, strings, comments or other roles.
• tiny.sys: Code above lib/sys reaches the platform through this surface, and the platform-sensitive parts of std, libc, @cImport, and the platform libraries stay below it.
• tiny.termtex: TeX-like mathematical syntax parsing, two-dimensional box layout, and terminal formatting.
• tiny.tldr: The package is an experimental linker: it takes compiled object files and static archives, resolves each reference to a symbol against the object that defines it, applies the relocations each target architecture defines, and writes one executable.
• tiny.trace: The package records a run as a stream of events and replays that stream back into the program.
• tiny.tracy: The package instruments a running program, writes what it observes as a trace, and analyzes those traces afterwards.
• tiny.tripwire: The excerpt below, from BufferPublication.stageAndPublish, shows one operation that takes a private copy of a payload, holds it, and then publishes it, with an error path open between the copy and the publish.
• tiny.ui: Package root for the envelope namespace and the retained tree namespace.
• tiny.wayland: The package lets a Zig program act as a client of a Wayland compositor, the program that draws a Linux desktop: it frames the messages between the two, names the objects those messages are about, passes open files across, and sets up the shared memory that holds a window's pixels.
• tiny.windowing: The package gives a program its own windows on the desktop: it opens and closes them, delivers the keyboard, mouse and gamepad input aimed at them, and shows the images the program draws, on macOS and on Linux under Wayland or X11.
• tiny.xkb: The package turns key presses into the symbols and text a program acts on: it compiles a keyboard layout, tracks which modifier keys are in force, and resolves sequences of key presses that produce one character.
• tiny.zen: Technical document compilation, static site rendering, and staged publication.

Internal implementation

Internal implementation packages supply subsystem machinery within Tiny. They are not exported as root namespace packages, but their interfaces, lifetime invariants, and failure modes are indexed here for contributors and researchers.

• alloc_arena: ## Shared temporary lifetimes
• alloc_fixed: ## Package overview
• alloc_observe: ## Layered allocation and operation hierarchy
• alloc_phase: ## Package overview