SDK modules
Every gizlang:NAME module with its public declarations. Import a module by name, for example import {parse} from "gizlang:json";. Each page lists the module's public declarations exactly as an installed toolchain provides them.
| Module | Purpose |
|---|---|
| gizlang:acme | ACME v2 (RFC 8555). |
| gizlang:bench | benchmarks as data. A suite declares its items (the rows of published tables), its tables (groups, with their method), its goals, and one function that measures the chosen items at a size. |
| gizlang:capability | The kernel and library capabilities this process has, probed when asked. |
| gizlang:collections | |
| gizlang:compress | DEFLATE (RFC 1951), gzip (RFC 1952) and CRC checksums, written in Gizlang. |
| gizlang:core | Values that may fail or be absent. |
| gizlang:crypto | Modern cryptographic primitives in Gizlang (RFC 5869/8439/7748/8032). |
| gizlang:csv | CSV retains bytes and reuses one record's range table: no field copies in next/field/integer. |
| gizlang:erasure | Erasure codes over GF(2^8) (polynomial 0x11D): Reed-Solomon and locally repairable codes (LRC). |
| gizlang:functions | compiled units that a running program loads: new Function sources (JavaScript) and kernels (Gizlang functions over columns, which a database generates for a statement). |
| gizlang:gateway | the front door of a host. |
| gizlang:gguf | GGUF files, llama.cpp's model format. |
| gizlang:grpc | gRPC (https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md) over HTTP/2. |
| gizlang:html | HTML as a typed value. |
| gizlang:http | HTTP/1.1 (RFC 9112) over any Stream of gizlang:system, so HTTPS is the same code over a stream secured by gizlang:tls. |
| gizlang:http3 | an HTTP/3 server (RFC 9114) over the QUIC of OpenSSL 3.5 or later (found at run time; supported says whether this host has it). |
| gizlang:hub | the files of Hugging Face Hub repositories in a local folder, at REPO/FILE as the hub serves them. |
| gizlang:image | JPEG, PNG and WebP pictures decoded at the smallest scale that a use needs, scaled, turned upright and coded again, written in Gizlang. |
| gizlang:journal | Shared log coordinates. |
| gizlang:json | JSON (RFC 8259) as a value, read with parse and written with stringify as JavaScript's JSON.stringify writes it. |
| gizlang:linalg | dense linear algebra over row-major buffers: f32 vector products and distances (BLAS level 1), and in f64 products, Cholesky, the symmetric eigendecomposition (cyclic Jacobi), least squares and the principal components. |
| gizlang:live | State that survives code changes. |
| gizlang:locale | the linguistic data of the Unicode CLDR (48.2.3, pinned; the CLDR generator writes the tables at the end of this file) and the algorithms that read it, once for the server, the browser and workers. |
| gizlang:machine | What this machine is: its CPU's instruction-set features, the CPUs this process may use, the caches they share and the memory nodes, detected at run time by the runtime, never inferred from a model name. |
| gizlang:math | IEEE 754 primitives and general numerical kernels. |
| gizlang:memory | |
| gizlang:mesh | which servers of one service are alive, and which of them owns a key. |
| gizlang:metrics | counters, gauges and histograms that every thread of a process can change without a lock or an allocation, and their exposition in the Prometheus text format 0.0.4 (GET /metrics). |
| gizlang:mp4 | MP4 files (ISO/IEC 14496-12 and 14496-14) of a video track (H.264, HEVC or AV1) and an AAC-LC track (ISO/IEC 14496-3). |
| gizlang:native | Native code a library did not compile itself: a dynamic library's symbols and calls through them (a GPU driver), raw memory, a generated CPU kernel run on every core, and a native resource a Gizlang value owns. |
| gizlang:natural | natural numbers of any size, for the integer and decimal types built on them (vm/bigint's Python int and JavaScript BigInt, db/decimal's wide NUMERIC). |
| gizlang:odbc | Thin ODBC driver boundary. |
| gizlang:path | |
| gizlang:pdf | the words of a PDF file (ISO 32000-2), as search and reading need them: each page's text in the order its content streams draw it, a line where the text moves to another line and a space where it jumps right (by the font's glyph widths). |
| gizlang:postgres | PostgreSQL protocol v3 over System's Stream. |
| gizlang:protobuf | the Protocol Buffers wire format. |
| gizlang:random | a seeded generator (SplitMix64), so a run can be repeated from its seed. |
| gizlang:regex | regular expressions with JavaScript's syntax and match results (leftmost match; alternatives and quantifiers prefer as written; lazy quantifiers; capture groups) over UTF-8 text, in time linear in the text. Structure (as RE2 and Rust's regex): a pattern parses to a tree over code-point sets. |
| gizlang:runtime | The runtime written in Gizlang: what the compiler lowers a construct to (the compiler appends this module wherever string( occurs). |
| gizlang:safetensors | safetensors files and the model folders that hold them. |
| gizlang:security | Shared identity, session proof and authorization decisions. |
| gizlang:sqlite | SQLite through its C library (giz bind wrote the declarations, reviewed by hand). |
| gizlang:stats | descriptive statistics over f64 samples: moments, order statistics and the sort they share; streaming moments, variance and least squares (the SQL aggregates and their merges). |
| gizlang:stringprep | SASLprep (RFC 4013) as PostgreSQL 16 runs it on SCRAM passwords: the frozen Unicode 3.2 stringprep ranges of RFC 3454 and the SDK normalizer, including its normalization corrections. |
| gizlang:system | The program's authority: files, network, arguments and environment. |
| gizlang:task | Structured tasks. |
| gizlang:test | assertions, generated inputs and shrinking, for test functions (function testName(): void, run by giz test FILE) and for programs. An assertion that does not hold faults (R004) inside itself, so the fault trace carries what failed with its values and where it was called: equal line 1 (actual = 4, expected = 5) <- testAdd (main.giz:12). |
| gizlang:text | Text and byte operations written in Gizlang over the built-in string primitives (slice, comparison, concatenation, push, string()). |
| gizlang:time | calendar dates in UTC from milliseconds since 1970-01-01, as JavaScript's Date keeps them (proleptic Gregorian; System.time() is now). |
| gizlang:tls | TLS over a TCP Stream of gizlang:system. |
| gizlang:unicode | |
| gizlang:url | the URL Standard (url.spec.whatwg.org) over UTF-8 bytes: the basic URL parser with its state overrides (the API's setters), the host parser (IPv4, IPv6, opaque hosts, and domain to ASCII), and the serializer with the offsets of each part, as ada's url_aggregator keeps them. |
| gizlang:worker | giz's inference worker protocol, version 1 (giz's ml/worker and wgp-api speak it): a service takes jobs over HTTP on a thread of its own, the caller runs them one at a time where its models are, and the worker keeps each result until giz acknowledges it. POST /v1/jobs takes {operation, model, input, idempotencyKey} as JSON, or as the form field "request" with the files it names ({"$file": field}), which stream to disk as they arrive; the executor sees each such file as {"$inputFile": {name, contentType, path}}. |