Vitte

Stdlib Reference Atlas

This atlas turns the Vitte stdlib into a wiki-style reference set: one landing page, one page per family, one page per concrete file, and one portrait SVG per module so the tree stays navigable even when it gets large.

What this corpus covers

  • Every .vit and .vitl file under src/vitte/stdlib.
  • Family pages aligned with the actual tree and its generated README.md contracts.
  • Wiki-style portraits and module infoboxes inspired by the keyword pages.
  • Searchable HTML pages generated directly from the repository source tree.

async

Future, channel, executor, and task orchestration helpers.

Architecture role: Use `async` when work should be coordinated as tasks rather than as direct thread ownership.

Visible files: 4

collections

Container and traversal surfaces such as vector, deque, queue, stack, linked list, hashmap, hashset, graph, and matrix.

Architecture role: Use `collections` when the shape of data matters more than the host system. This family owns grouping, ordering, indexing, and traversal concerns.

Visible files: 11

compiler

Compiler-owned stdlib surfaces that support self-hosted compiler and driver integration.

Architecture role: This family is not general-purpose business code. It exists to support compiler-owned flows where the compiler and stdlib need a shared contract.

Visible files: 27

compression

Algorithms and interfaces for compacting data: huffman, lz, deflate, brotli, stats, and shared compression interfaces.

Architecture role: Use `compression` when compactness is a first-class requirement and the program must explain which algorithmic boundary owns that transformation.

Visible files: 9

core

Portable low-level building blocks: types, strings, memory helpers, panic/runtime-adjacent basics, and reusable utility routines.

Architecture role: Use `core` when the code should remain portable and unsurprising. It is the family you reach for before involving the filesystem, network, process table, or threading runtime.

Visible files: 9

crypto

Hashing, HMAC, randomness, key derivation, symmetric primitives, and asymmetric primitives.

Architecture role: Use `crypto` when integrity, secrecy, or key management is the feature. This family should never be presented as generic formatting or utility code.

Visible files: 9

data

Dataset-oriented helpers such as schema, transform, merge, cleaning, and statistics.

Architecture role: Use `data` when the program manipulates rows, records, schemas, or staged transformations instead of one-off scalar logic.

Visible files: 7

encoding

Text and byte encoding surfaces such as utf, base64, url, hex, html, legacy encodings, and unicode helpers.

Architecture role: Use `encoding` when values cross a textual or byte-oriented boundary and representation matters.

Visible files: 9

ffi

ABI and foreign-function boundaries used when Vitte code must cross language or runtime edges.

Architecture role: Use `ffi` only when the program really needs a foreign boundary. This family should make coupling visible instead of hiding it.

Visible files: 2

io

File, buffer, stream, stdio, and host-runtime access helpers.

Architecture role: Use `io` when the program must read or write bytes, files, or streams. Keep it separate from validation, parsing, or business decisions.

Visible files: 8

json

Structured JSON surfaces including parse, parser, types, builder, schema, stringify, and serialize.

Architecture role: Use `json` when data must cross a structured textual boundary. This family owns JSON shape and conversion, not business validation itself.

Visible files: 8

kernel

System-facing runtime helpers such as process, scheduler, threads, sync, users, signals, network, device, and memory.

Architecture role: Use `kernel` when the program explicitly models system services, scheduling, process behavior, or device-facing coordination.

Visible files: 12

math

Arithmetic, algebra, comparison, calculus, geometry, modular arithmetic, number theory, probability, statistics, matrix, and vector helpers.

Architecture role: Use `math` when the transformation itself is the feature. This family exists so algorithmic intent stays visible and testable.

Visible files: 21

path

Path manipulation, special locations, walkers, and globbing.

Architecture role: Use `path` when the program needs path semantics, traversal, or normalization. Keep it distinct from file contents and from business validation.

Visible files: 5

stdlib

Top-level map of the Vitte standard library and the responsibilities owned by each family.

Architecture role: A realistic Vitte program usually starts in `core`, grows through `collections` or `data`, crosses textual boundaries with `json` or `encoding`, touches the host with `path` or `io`, and only then reaches system-facing families like `kernel`, `ffi`, `async`, or `threading`.

Visible files: 11

tests

Stdlib-focused smoke and integration validation surfaces.

Architecture role: This family exists to prove that the documented stdlib surfaces keep behaving as promised.

Visible files: 1

threading

Thread, mutex, and pool-based concurrency helpers.

Architecture role: Use `threading` when the program needs explicit concurrency coordination rather than single-threaded transformation.

Visible files: 3