The standard library · FutureBlitz

Core

Print and Input, errors, iterators, formatting and parsing, events, logging, and tests.

std.core.assert AssertEqual, an Assert that says what it compared.
std.core.error Error, the Class every error extends, and each area's own Error.
std.core.format Formatting by a template the program has only when it runs, and the debug form.
std.core.interfaces The Interfaces that operators and string conversion work through.
std.core.iterator Iterators, and the Iterable Interface, which For loops go over besides arrays.
std.core.load The attributes and Interfaces that change how Load and Save convert a type.
std.core.parse Parsing numbers and Bools from text.
std.core.print Writing to stdout and stderr, and reading lines from stdin.
std.core.range Ranges of integers, as For loops count them.
std.core.value Value, data of any shape, as the data formats read and write it.
std.core.values Min, Max, Clamp, Swap, and HashCombine, for any values.
std.events.event Events, which call the handlers subscribed to them when they're emitted.
std.log.files Log sinks that write to files, rotated or not.
std.log.level Log levels, and the filter that picks each module's least level.
std.log.logger Logger, which writes a module's lines, with levels and fields.
std.log.output What a Logger writes, and the output that hands it to sinks.
std.log.sinks Log sinks for the console and for JSON lines.
std.test Expect, ExpectThrows, Fail, and Skip, what fb test's tests check with.
std.debug.debugger Breakpoints in code, and whether a debugger is attached.

Collections

Map, Set, Stack, Queue, Deque, PriorityQueue, caches, and graph and grid algorithms.

std.collections.array Searching, sorting, reshaping, and the other Methods every array has.
std.collections.bit_set A set of Ints from 0 up, a bit each.
std.collections.counter A count of how many times each value was added.
std.collections.deque A double-ended queue, which adds and takes values at either end.
std.collections.grid Fixed-size 2D and 3D grids of values, read and set by position.
std.collections.immutable Arrays, maps, and sets that never change, so any thread can read them.
std.collections.interval_tree A tree of values over intervals, which finds those that overlap an interval or hold a key.
std.collections.linked_list A doubly linked list, which adds and removes values beside a node in constant time.
std.collections.lru_cache A cache of up to a set number of entries, which drops the one used least recently.
std.collections.map A hash map that keeps its entries in the order they were added.
std.collections.multi_map A map from each key to one value or more.
std.collections.pool Values kept by Handles, which find nothing once their value is removed.
std.collections.priority_queue A priority queue, whose Pop gives the value that comes first.
std.collections.queue A first-in, first-out queue.
std.collections.ring_buffer A fixed number of the last values added, oldest first.
std.collections.set A set of values without repeats, in the order they were added.
std.collections.sorted A map and a set that keep their keys in order, in a B-tree.
std.collections.spatial Spatial hashes, quadtrees, and octrees, which find values by where they are.
std.collections.stack A last-in, first-out stack.
std.collections.trie A prefix tree of String keys, which finds the keys that start with a prefix.
std.collections.view Views of arrays, maps, and sets, which show them without copying.
std.algo.combinatorics Every order and every choice of an array's elements, and how many of each there are.
std.algo.delaunay Delaunay triangulation, Voronoi diagrams, and Lloyd relaxation of points in 2D.
std.algo.grid Neighbors, A* paths, and flow fields on grids of cells.
std.algo.search Breadth-first search, depth-first search, Dijkstra, and A* over any graph.
std.algo.topological Topological sorting of a graph's nodes, and finding the cycle that keeps one from being.
std.algo.union_find Disjoint sets of Ints that only ever join, for what's connected to what.

Text

Unicode, regular expressions, Markdown, templates, diffs, fuzzy matching, and encodings.

std.text.builder StringBuilder, which builds text a piece at a time.
std.text.char A Char's code, kind, and case.
std.text.diff The differences between two texts, by lines or characters, and three-way merges.
std.text.encoding Text encodings, Base64, hex, and Base32, and escaping text for URLs, HTML, and string literals.
std.text.fuzzy Fuzzy matching of text, as fzf does it.
std.text.glob Matching text against a shell's wildcard patterns.
std.text.humanize Numbers, sizes, times, and names written as people say them, in English.
std.text.layout Wrapping, dedenting, and indenting a String's lines, and the edit distance between two.
std.text.markdown CommonMark Markdown, as HTML or as a tree.
std.text.regex Regular expressions, by PCRE2.
std.text.scanner Scanner, which reads text a piece at a time, for a parser.
std.text.string Searching, slicing, splitting, and changing Strings.
std.text.template Mustache-style templates, filled from Values and other types.
std.text.unicode What Unicode says of characters: categories, normal forms, case folding, and widths.

Data formats

JSON, MessagePack, TOML, CSV, INI, XML, YAML, Protocol Buffers, and SQLite databases.

std.data.csv Reading and writing comma-separated values.
std.data.ini Reading and writing INI files.
std.data.json Reading and writing JSON.
std.data.msgpack Reading and writing MessagePack.
std.data.protobuf Protocol Buffers' wire format and text format, for the types made from .proto files.
std.data.text What std.data's formats share in reading and writing text.
std.data.toml Reading and writing TOML.
std.data.xml Reading and writing XML documents, as trees and as Values.
std.data.xml_path XPath's location paths over an XML document's tree.
std.data.xml_reader Reading XML as a stream of events.
std.data.yaml Reading and writing YAML.
std.data.yaml_scanner YAML's tokens, as a scanner reads them from text.
std.db.database SQLite databases: statements, queries, transactions, and migrations.

Files and streams

Paths, files, folders, streams, memory-mapped files, a virtual file system, and file watching.

std.io.binary Reading and writing numbers, Bools, bytes, and text in binary, in either byte order.
std.io.buffered Buffered readers and writers over other streams.
std.io.dir Making, listing, and removing folders, and finding paths by glob patterns.
std.io.file Reading, writing, copying, moving, and deleting whole files at once.
std.io.file_stream Open files, which read, write, and seek as streams.
std.io.lock Locks on files, which other programs see.
std.io.mapped Files mapped into memory, read and written in place.
std.io.memory Streams over bytes and Strings in memory.
std.io.path Paths of files and folders, by Windows' rules or POSIX's.
std.io.preferences A program's settings, kept between its runs where the OS keeps them.
std.io.request What std.io's file calls share.
std.io.streams Reader, Writer, and Seeker, the streams that files and sockets are, and copying between them.
std.io.temp Temporary files and folders, removed when they're closed.
std.io.vfs A virtual file system of folders, embedded files, and zips, mounted in one tree.
std.io.watcher Watching files and folders for changes.

Networking and HTTP

Addresses, DNS, TCP and UDP, TLS, an HTTP client and server, WebSockets, and ACME.

std.net.acme What automatic HTTPS needs of ACME, as Let's Encrypt speaks it.
std.net.acme_client An ACME client, which gets certificates from a CA like Let's Encrypt.
std.net.address IP addresses, and socket addresses with ports.
std.net.dns Looking up the addresses a host's name has.
std.net.game.channel What each channel of a connection does with its messages.
std.net.game.host GameHost, one end of any number of connections, which reports what happens as events.
std.net.game.link What a GameHost sends its packets over, and receives them from.
std.net.game.packet The packets a GameHost sends, as they go over the wire.
std.net.game.peer The other side of a connection, as a GameHost has it.
std.net.game.settings The settings a GameHost and its peers share, and why a connection ends.
std.net.http.client An HTTP and HTTPS client.
std.net.http.files Serving a folder's files over HTTP.
std.net.http.headers HTTP header fields, whose names match in any letter case.
std.net.http.routes Routes made from a Class's Methods, by attributes like @Get.
std.net.http.server An HTTP and HTTPS server, whose handlers run on the main thread.
std.net.http.status HTTP status codes and their reasons.
std.net.http.wire HTTP/1.1 messages as their bytes go over the wire, per RFC 9112.
std.net.http.work Blocking route handlers, run on a server's worker threads.
std.net.ipc Connections between programs on one machine.
std.net.lan Offering and finding services on the LAN, over mDNS and DNS-SD.
std.net.socket What std.net's sockets share.
std.net.tcp TCP connections and listeners.
std.net.tls TLS 1.2 and 1.3 over any stream.
std.net.udp UDP sockets, with broadcast and multicast.
std.net.url URLs and query strings, as the WHATWG URL Standard has them.
std.net.ws.handshake A WebSocket's opening handshake, over HTTP/1.1.
std.net.ws.websocket WebSocket clients and servers.

Concurrency

Locks, concurrent maps and queues, lazy values, parallel algorithms, and cancellation.

std.concurrent.cancellation A flag that stops blocking calls and work under way, on any thread.
std.concurrent.channels Waiting on several Channels at once, and Channel waits that a Cancellation stops.
std.concurrent.concurrent_map A hash map that any number of threads read and change at once.
std.concurrent.concurrent_queue A first-in, first-out queue for any number of threads at once.
std.concurrent.lazy A value made once, the first time any thread asks for it.
std.concurrent.locks Semaphores, barriers, wait groups, Once, and read-write locks, for any thread.
std.concurrent.parallel Parallel ForEach, Map, Reduce, and Sort over arrays, on the job pool.
std.concurrent.tasks Combining Tasks, and finishing a Task by hand.

Math

Vectors, matrices, colors, geometry, random numbers, noise, statistics, units, and big numbers.

std.math.big.bigint Integers of any size.
std.math.big.complex Complex numbers, as two Doubles.
std.math.big.decimal Decimal numbers, which hold decimal fractions like 0.1 exactly.
std.math.big.rational Exact fractions of BigInts.
std.math.bits Counting, rotating, swapping, and aligning an integer's bits, and saturating arithmetic.
std.math.color Colors, as sRGB bytes and as linear Floats.
std.math.constants Math's constants, like Pi and E, as Floats and as Doubles.
std.math.curves Bezier curves, splines, and paths through points, in 2D and 3D.
std.math.easing Easing curves for animation, from 0 at the start to 1 at the end.
std.math.fixed Fixed-point numbers, whose math gives the same bits on every OS and CPU.
std.math.geometry Rectangles, boxes, spheres, rays, planes, and frustums, and the tests between them.
std.math.int_vector Integer 2D and 3D vectors, for grid cells and the steps between them.
std.math.matrix 3x3 and 4x4 matrices of Floats, column-major, as the GPU takes them.
std.math.noise Perlin, Simplex, value, and cellular noise, and fractal Brownian motion.
std.math.numbers The Interfaces the number types share, for generic math: Bounded, Integer, and FloatingPoint.
std.math.polygon Polygons: their areas, hulls, triangles, and the union, intersection, and difference of two.
std.math.quat Quaternions, for rotations in 3D.
std.math.random A seeded random number generator that gives the same numbers on every platform.
std.math.scalar Math on single numbers: signs, rounding, remainders, powers, logs, and trigonometry.
std.math.stats Statistics: mean, median, variance, standard deviation, percentiles, and histograms.
std.math.units Quantities with units of length, mass, and time, which the compiler keeps apart.
std.math.vector 2D, 3D, and 4D vectors of Floats.

Time

Durations, timestamps, dates and times of day, calendars, timers, and time zones.

std.time.calendar Dates, times of day, and the two together, without a time zone.
std.time.clock The monotonic clock, for measuring how long things take, and Sleep.
std.time.duration Durations, spans of time to the nanosecond.
std.time.format Formatting and parsing dates and times: ISO 8601, RFC 2822, and patterns.
std.time.timers Timers, deadlines, fixed steps, rate limits, and debouncing.
std.time.timestamp Timestamps, points in time in UTC, to the nanosecond.
std.time.zone Time zones, and times in them: the IANA database's, fixed offsets, and the OS's.

Crypto and compression

Hashes, ciphers, signatures, password hashing, UUIDs, and Deflate, Zstd, Zip, and tar.

std.crypto.blake3 The BLAKE3 hash, also keyed, as a MAC, and as a key derivation function.
std.crypto.checksums CRC-32 and XXH3, fast checksums that aren't cryptographic.
std.crypto.ciphers Authenticated encryption, by AES-256-GCM and ChaCha20-Poly1305.
std.crypto.derive HMAC, HKDF, and PBKDF2: message authentication and key derivation.
std.crypto.hashes The MD5, SHA-1, SHA-256, and SHA-512 hashes.
std.crypto.passwords Hashing and checking passwords, by Argon2id and bcrypt.
std.crypto.pem Reading keys and X.509 certificates from PEM, and writing keys to it.
std.crypto.random Random bytes and numbers from the OS, for secrets, and comparing secrets in constant time.
std.crypto.signatures Signatures and key exchange: Ed25519, ECDSA P-256, RSA, and X25519.
std.compress.archive The entries that the zip, tar, and 7z readers give.
std.compress.codec What std.compress's formats share: the Coder Interface, limits, and errors.
std.compress.deflate Deflate, Zlib, and Gzip compression.
std.compress.lz4 LZ4 compression, in its frame format.
std.compress.seven_zip Reading 7z archives.
std.compress.stream Compressing and decompressing streams as they're written and read.
std.compress.tar Reading and writing tar archives.
std.compress.vfs Zips mounted in std.io's virtual file system.
std.compress.xz The .xz compression format.
std.compress.zip Reading and writing zip archives.
std.compress.zstd Zstandard compression.
std.uuid.uuid UUIDs: random version 4 identifiers, and their text.

Images and the terminal

PNG, JPEG, GIF, WebP, and SVG images, drawing and fonts, and terminal styles, input, and widgets.

std.image.animation Animations: frames of Images, each shown for a time.
std.image.bitmap BMP, TGA, and QOI images.
std.image.canvas Drawing lines, shapes, paths, images, and text on an Image.
std.image.codec What std.image's formats share: limits, decoded images, and errors.
std.image.font TrueType and OpenType fonts, read safely from bytes or a file.
std.image.gif Reading and writing GIF images and animations.
std.image.hdr High dynamic range images, and Radiance's HDR files.
std.image.image Image, a picture's RGBA pixels in memory, and what changes them.
std.image.jpeg Reading and writing JPEG images.
std.image.png Reading and writing PNG images and APNG animations.
std.image.svg Reading SVG images and drawing them into Images.
std.image.webp Reading and writing WebP images.
std.term.console The console: whether its streams are terminals, its size, and reading keys and passwords.
std.term.input Turning what a terminal sends into key, mouse, and paste events.
std.term.prompts Asking yes or no, for one of some options, or for a line of text.
std.term.region Laying out a screen's cells in rows and columns.
std.term.screen Full-screen terminal apps, which draw only the cells that changed.
std.term.style Colors and text attributes for what a terminal shows.
std.term.terminal A Terminal, where widgets and full-screen apps write and keys come from.
std.term.views Text inputs and list views for full-screen terminal apps.
std.term.widgets Tables, boxes, progress bars, and spinners for a terminal's lines.

OS and processes

Command-line arguments, the environment, standard folders, processes, signals, and C data.

std.os.args Reading a program's command line into a Struct or Class.
std.os.env The environment's variables, and loading them from .env files.
std.os.folders Where the OS keeps the user's and the program's files, and opening a file in its app.
std.os.process The program's own process: its Id, and ending it.
std.os.process_child A running child process: its streams, waiting for it, and ending it.
std.os.process_command Starting other programs, with their arguments, environment, and streams.
std.os.process_signals Handling the interrupt and terminate signals.
std.os.system What the program knows of the machine it runs on.
std.ffi.buffer Native memory of C values, which C code and safe code share without copying.
std.ffi.cdata CData, the constraint for the types C code has.
std.ffi.cstring CStrings that C code can keep: copies of Strings, their lengths, and freeing them.
std.ffi.mem Raw memory for Unsafe code: allocating, copying, filling, comparing, and freeing it.