Search modules and functions. Stable production docs should grow from this generated base.
actor module: local actor/mailbox and OTP-style supervision foundation. This is the stable API shape for TezzNative actor work. The current implementation is deterministic and in-process; future native runtimes can replace the internals with real schedulers, IOCP/io_uring, and distribution.
47 functions detected.
ai module — TezzNative Unified On-Device AI Entry Point This is the single top-level import for any TezzNative AI program. It provides: - Hardware detection and initialization - Convenience wrappers for the most common AI tasks - Access to all AI subsystems via a single import Import hierarchy: ai → device, model, pipeline, nn, llm, npu, simd, tensor quant, optim, grad, dataloader, metric, stt, tts, tokenizer Quick Start: import "ai" fn main() -> int: ai.init() // detect hardware, print report result:str = ai.generate("model.tnw", "Hello, world!", 64) say result ai.shutdown() ret 0
43 functions detected.
Optional native C-kernel bridge for AI hot loops. These functions are intended for native builds that link matching C objects.
12 functions detected.
arduino module — TezzNative 2.0 Arduino Hardware Abstraction Layer Enables writing native TezzNative programs for Arduino AVR boards. Compiles to AVR machine code via TezzNative's cross-compile target: tezzc buildexe --target=avr-atmega328p main.tn main.hex Supported boards (via target flag): avr-atmega328p — Arduino Uno, Nano, Mini avr-atmega2560 — Arduino Mega avr-attiny85 — Digispark, ATtiny85 All timing functions use AVR hardware timers (no floating-point). All I/O maps directly to AVR port registers (PORTB, PORTC, PORTD). Usage: import "arduino" fn setup() -> int: arduino.pin_mode(13, arduino.OUTPUT) ret 0 fn loop() -> int: arduino.digital_write(13, arduino.HIGH) arduino.delay(500) arduino.digital_write(13, arduino.LOW) arduino.delay(500) ret 0 fn main() -> int: setup() while 1: loop() ret 0
70 functions detected.
arena module — bump/arena allocator for fast batch allocation Arenas allocate from a contiguous buffer and free all at once. Use for temporary computation, parser state, request lifetime, etc. Usage: a:*Arena = arena_new(1024 * 1024) // 1 MB arena buf:*char = arena_alloc(a, 256) // bump-allocate 256 bytes arena_reset(a) // free all at once (O(1)) arena_free(a) // release arena itself
13 functions detected.
autodiff module (Phase 4 scaffold)
29 functions detected.
automation.tn — Scripting & Task Automation Library for TezzNative Provides high-level utilities for: - Process Execution & Output Capturing - Environment Variable Queries - File System Operations & Directory Sweeps - Text Filtering & Regex-based Pipeline Processing
9 functions detected.
bench module — benchmark measurement helpers for TezzNative Stability: Beta Aligned with the BENCHMARKS.md CSV/JSON schema. Uses time.time_now_ms() for wall-clock timing. Usage: import "bench" import "time" bh:*BenchHandle = bench_start("matrix_mul", "math", 1000) i:int = 0 while i < bench_iters(bh): bench_iter_start(bh, i) // ... work ... bench_iter_end(bh, i) i = i + 1 bench_report(bh) bench_free(bh)
17 functions detected.
cli module — command-line argument parser for TezzNative Stability: Beta Depends: runtime
20 functions detected.
color module — TezzNative 2.0 Native Color & Style System Full TrueColor (24-bit RGB) ANSI terminal support for CLI and GUI programs. Auto-detects TrueColor capability. Falls back gracefully to 256-color or basic. Features: • RGB TrueColor foreground/background • 256-color palette (xterm256) • Standard 16 named colors • Text styles: bold, italic, underline, dim, blink, reverse, strikethrough • Styled string builder: compose multi-attribute styled text • Progress bar renderer (animated, colored) • Table renderer (bordered, colored headers) • Gradient text renderer • Pixel-native RGBA color packing/unpacking • CLI spinner animation frames • Color detection: TrueColor / 256 / 16 / none
97 functions detected.
config module — INI-style configuration file support for TezzNative Stability: Beta Depends: runtime (for atoi, atof, getenv, fgets, memcpy) Supports key=value pairs with optional [section] headers. Supports environment variable overrides. Missing file: returns defaults safely. Usage: import "config" cfg:*Config = config_load("app.ini") val:str = config_get(cfg, "server", "host", "localhost") port:int = config_get_int(cfg, "server", "port", 8080) config_free(cfg)
24 functions detected.
lib/cuda.tn -- TezzNative CUDA runtime extern wrappers Provides CPU-side access to cudaMalloc, cudaFree, cudaMemcpy for GPU tensor allocation and host<->device data transfer. Usage (CUDA-target only, compile with: tezzc buildcuda foo.tn foo.cu): import "cuda" gptr: int = cuda.cu_malloc(numel * 8) // returns device pointer as int cuda.cu_h2d(gptr, host_ptr, numel * 8) // upload cuda.cu_d2h(host_ptr, gptr, numel * 8) // download cuda.cu_free(gptr)
11 functions detected.
cyber module: Hacking and Cybersecurity utilities for TezzNative. Provides rapid prototyping tools for security research, penetration testing, and cryptography.
6 functions detected.
Core SDK module.
14 functions detected.
dataloader module — TezzNative Dataset Pipeline In-memory dataset management with shuffle, batch iteration, train/val split, CSV/TSV reader, and normalization helpers. Designed for on-device AI training. All data lives in flat float64 slabs. Row layout: [feature_cols | label_cols] per sample. Usage: dl:*DataLoader = dataloader.load_csv("data.csv", 4, 1) dataloader.shuffle(dl, 42) val_dl:*DataLoader = dataloader.split(dl, 0.8) // 80% train, 20% val while dataloader.has_next(dl): x_buf:*float = malloc(batch * 4 * 8) as *float y_buf:*float = malloc(batch * 1 * 8) as *float n:int = dataloader.next_batch(dl, x_buf, y_buf, batch, 4, 1) ... train ... dataloader.reset(dl)
18 functions detected.
db.tn — Embedded TezzDB Engine for TezzNative Capabilities: • Persistent Key-Value & Relational JSON Document Store • Zero-dependency high-throughput embedded storage • SQL-like query interface: INSERT, SELECT, UPDATE, DELETE, QUERY • Bytecode transport optimization for fast CPU compute
8 functions detected.
device module — TezzNative On-Device AI Hardware Detection Queries CPU features (SSE2/AVX2/FMA/NEON/AMX), GPU presence, NPU vendor, estimated RAM, and recommends the best AI backend. Usage: device.ai_init() say "CPU: ", device.cpu_name() say "Best backend: ", device.best_backend_name() batch:int = device.max_batch_size()
36 functions detected.
Core SDK module.
2 functions detected.
event module: deterministic UI/input event queue primitives. Hosted runtime lanes implement these via builtins for stability.
10 functions detected.
frame module: deterministic rect + damage-region utilities for GUI compositors.
18 functions detected.
gen_server.tn — Erlang/Elixir Generic Server (GenServer) Behavior for TezzNative Implements client-server RPC pattern with state stored cleanly in `.log/` directory.
5 functions detected.
gpu module: experimental GPU compute abstraction for TezzNative. This module exposes runtime hooks for GPU-backed buffers and kernels. Real acceleration depends on the runtime build and the available backend. On builds without a GPU backend, runtime hooks may report unavailable or route callers through CPU fallback paths.
35 functions detected.
grad module — TezzNative Gradient Tape Gradient accumulator and management for on-device fine-tuning. Designed to work with nn.tn's slab-based NeuralNet. A GradTape is a flat float64 slab that shadows the parameter slab of a NeuralNet. It accumulates gradients across mini-batches and supports zeroing, scaling, and norm computation. Usage: // Shadow a neural net's parameter space tape:*float = grad.tape_new(n_params) grad.zero(tape, n_params) // ... forward and backward pass accumulate grads ... grad.scale(tape, n_params, 1.0 / batch_size) // average optim.adam_step(params, tape, m1, m2, n_params, lr, step, ...) grad.zero(tape, n_params) // clear for next batch
22 functions detected.
gui module: minimal immediate-mode GUI for freestanding targets Uses the Limine framebuffer when available (via os.fb_* accessors).
24 functions detected.
gui_win.tn — TezzNative host-mode framebuffer + input bridge v1.1 Pure extern fn declarations — no OS/sys/freestanding imports. All GUI apps import this as their low-level display layer.
29 functions detected.
intrin module: low-level intrinsics and explicit SIMD kernels Bit operations route directly to hardware builtins (POPCNT, BSF, BSR, BSWAP) for maximum performance. Pure-TN fallbacks are used only as documentation.
31 functions detected.
io module — TezzNative 2.0 Production I/O Capabilities: • Standard file open/read/write/seek/close (all modes) • BigFile: streaming GB/TB/PB files via configurable chunk reads • StreamWriter: buffered high-throughput sequential writes • MmapFile: memory-mapped file view (software or OS-backed) • PipePair: inter-process pipe (anonymous pipe) • Path helpers: join, base, dir, norm, portable + OS-backed • Directory helpers: walk, glob, list recursive • File utility: copy, move, size, exists, remove, rename • Async stubs: aio_read_req, aio_write_req, aio_wait
118 functions detected.
json module — JSON parser and serializer for TezzNative Stability: Beta Depends: runtime (for memset, memcpy, atoi, atof, sprintf_int, fputs) All returned *JsonVal pointers are heap-allocated. Call json_free() when done. Uses an iterative stack-based parser — no recursion, no forward decls.
56 functions detected.
kernel module — TezzNative 2.0 OS Kernel Infrastructure Low-level kernel primitives for building operating systems, bare-metal programs, and hypervisors in TezzNative. Targets: x86_64 — full IDT, GDT, APIC, page tables aarch64 — exception vectors, MMU, GICv3 riscv64 — trap handler, PLIC, SBI interface Compile bare-metal: tezzc buildexe --target=x86_64-bare main.tn kernel.elf Usage: import "kernel" fn main() -> int: kernel.gdt_init() kernel.idt_init() kernel.pic_remap(0x20, 0x28) kernel.sti() kernel.vfs_mount("/", ramdisk_driver) while 1: kernel.hlt() ret 0
64 functions detected.
llm module — TezzLLM Production Inference Engine & Sampler GPT-style Transformer inference with KV-cache, INT8/INT4 quantization loaders, and state-of-the-art nucleus/top-k/temperature sampler. STRUCT-FREE SLAB ARCHITECTURE to ensure compatibility and performance.
12 functions detected.
llm_core: stable CPU fallback primitives for transformer inference. TezzNative `float` is ABI f64 today. These APIs are named f64 on purpose so model code does not confuse them with f32/f16/bf16 lanes.
66 functions detected.
log module — structured logging for TezzNative Stability: Beta Depends: runtime Levels: LOG_DEBUG < LOG_INFO < LOG_WARN < LOG_ERROR < LOG_FATAL Sinks: stdout (default) and/or file append.
27 functions detected.
math module — complete mathematical functions for TezzNative Maps to native runtime implementations for maximum performance.
57 functions detected.
metric module — TezzNative AI Evaluation Metrics Production evaluation metrics for classification, regression, language models, and generative tasks. Usage: acc:float = metric.accuracy(preds, targets, n) ppl:float = metric.perplexity(log_probs, n_tokens) f1:float = metric.f1_binary(preds, targets, n) metric.confusion_matrix(preds, targets, n, n_classes)
20 functions detected.
============================================================ mind.tn — TezzMind Core GQA Transformer Model Library v3.0 ============================================================
44 functions detected.
ml module: unified AI/ML surface for TezzNative
97 functions detected.
Win32 Mmap Wrapper for TezzNative Used for instantly mapping massive .gguf AI model files into memory
7 functions detected.
model module — TezzNative Unified Model Manager Handles loading, inspection, and lifecycle of AI models in multiple formats: - .tnw (TezzNative native weight binary) - .onnx (via npu.model_load) - raw binary weight slabs (direct float64 arrays) Dispatches inference to the best available backend: NPU (ONNX RT) > GPU > SIMD CPU Usage: m:*Model = model.open("my_model.tnw") if model.is_ready(m): model.info(m) out:*float = malloc(out_n * 8) as *float model.infer(m, input, in_n, out, out_n) model.close(m)
11 functions detected.
Core SDK module.
9 functions detected.
nano_llm.tn — Specialized Task-Specific Nano LLM Framework for TezzNative Designed for ultra-fast, zero-latency execution of single-task AI models (5M–50M parameters) on CPU, SIMD, GPU, and NPU. Supports: 1. Task-Specific Architecture Construction (Grouped Query Attention, SwiGLU, RMSNorm). 2. Task-Constrained Decoding (JSON extraction, intent classification, tool routing). 3. Quantized INT8/INT4 weight inference for embedded edge devices.
8 functions detected.
net module: production network baseline for TezzNative. Scope in v1.0: - TCP + UDP socket wrappers - DNS endpoint helpers + URL utilities - TLS socket handle wrappers - HTTP/HTTPS convenience helpers (client + minimal server helpers) - WebSocket handshake + frame helpers - Native runtime-backed URL downloader Notes: - This module is the production baseline for app/service networking. - HTTP/2, QUIC, SMTP/IMAP, and full proxy stacks remain future milestones.
192 functions detected.
============================================================ nn.tn - TezzAI Neural Network Library v7.0 ============================================================ STRUCT-FREE ARCHITECTURE: The TezzNative compiler has severe bugs with structs (field offsets, pass-by-value corruption). Therefore, we use NO STRUCTS. A "NeuralNet" is simply a single *float slab pointer. SLAB slots (each slot = 8 bytes): [0] magic [1] n_layers [2] total_w [3] total_b [4..11] l_in_n[8] [12..19] l_out_n[8] [20..27] l_act[8] [28..35] l_w_off[8] [36..43] l_b_off[8] [44..] weights[total_w] [44+tw..] biases[total_b] [...+tb] outputs[total_b] [...+tb] deltas[total_b] [...+tb] grad_w[total_w] [...+tw] grad_b[total_b] ============================================================
49 functions detected.
npu module: experimental neural accelerator abstraction for TezzNative. This module exposes runtime hooks for ONNX/DirectML/CoreML/OpenVINO-style acceleration paths where the runtime was built with those backends. Callers must expect CPU/GPU fallback or "backend unavailable" results on platforms without a configured NPU runtime.
37 functions detected.
ocr module: Hindi-first OCR helpers (production baseline). Backend: - tesseract CLI (cross-platform) Notes: - This module provides deterministic command construction + extraction helpers. - For production OCR quality, install language data for Hindi (`hin`) and English (`eng`).
39 functions detected.
optim module - TezzNative Optimizer Library SGD, Adam, AdamW, RMSProp, Adagrad + learning rate schedules. All operate on flat float64 parameter slabs (nn.tn compatible).
20 functions detected.
os module: freestanding helpers for OS/kernel targets This module is intentionally minimal and only depends on `sys`.
252 functions detected.
otp.tn — One-Time Password (OTP & 2FA / TOTP / HOTP) Standard Auth Engine for TezzNative Compliant with RFC 6238 (TOTP), RFC 4226 (HOTP), and SMS/Email Numeric Verification Codes. Provides Base32 secret generation, HMAC-SHA1 authentication calculations, and QR Provisioning URIs.
9 functions detected.
otp_sys.tn — Erlang-Style OTP Core Actor Concurrency Runtime Stores internal actor states and mailboxes cleanly inside `.log/` directory.
11 functions detected.
pipeline module — TezzNative End-to-End AI Pipeline Provides one-call interfaces for the most common on-device AI tasks: - Text generation (LLM) - Speech-to-text (STT/Whisper-style) - Text-to-speech (TTS) - Classification (MLP) - Image classification (CNN via ONNX) The pipeline auto-selects the best hardware backend via device.tn and dispatches to npu/gpu/simd as appropriate. Usage: // Text generation result:str = pipeline.run_text("model.tnw", "Hello, how are", 64) // Speech-to-text text:str = pipeline.run_stt("model.tnw", "audio.wav") // Classification class_id:int = pipeline.run_classify("model.tnw", features, 128)
14 functions detected.
quant module - TezzNative Quantization Utilities INT8 symmetric, INT4 block, and FP16 conversion for running large AI models on device with reduced memory. All INT8/INT4 buffers use *char with manual bit manipulation since TezzNative uses *char for signed bytes.
17 functions detected.
raspi module — TezzNative 2.0 Raspberry Pi Hardware Abstraction Layer Native Raspberry Pi support for all GPIO and peripheral access. Works on RPi 1/2/3/4/5 via /sys/class/gpio and /dev/* interfaces. Also supports RPi Pico (RP2040) via USB serial bridge. Compile for RPi: tezzc buildexe --target=aarch64-linux main.tn main Compile for RPi Pico: tezzc buildexe --target=arm-cortex-m0 main.tn main.uf2 GPIO: /sys/class/gpio (kernel sysfs) — no root required PWM: /sys/class/pwm (kernel pwm driver) I2C: /dev/i2c-* (i2c-dev kernel module) SPI: /dev/spidev* (spidev kernel module) UART: /dev/ttyS0 or /dev/ttyAMA0 Camera: libcamera or V4L2 via /dev/video0
66 functions detected.
regex module — deterministic regular expression matching for TezzNative Stability: Beta Depends: runtime Supported patterns: . any character * zero or more (greedy) + one or more (greedy) ? zero or one (greedy) [abc] character class [^abc] negated character class [a-z] character range ^ anchor to start $ anchor to end \d digit [0-9] \w word character [a-zA-Z0-9_] \s whitespace [ \t\r\n] \n \r \t literal escapes (...) grouping (non-capturing) | alternation (between groups)
17 functions detected.
Core SDK module.
8 functions detected.
runtime module — C-stdlib compatibility layer for TezzNative Implements memcpy, memset, sprintf, atoi, atof, strncmp, getenv, fputs, fputc, fgets in pure TezzNative so all stdlib modules can depend on a mature, consistent runtime foundation. This is the foundation layer required before building LLMs, parsers, web servers, or any production-grade software in TezzNative. Stability: Core (required by json, log, config, regex, test, bench, cli)
51 functions detected.
simd module — TezzNative 2026 high-performance vector ops Width tiers: v4f_* — 4-wide f32 (SSE baseline, backward-compatible) v8f_* — 8-wide f32 (AVX2 tier, 2x throughput) v8i_* — 8-wide i32 AI kernels: relu, relu6, leaky, gelu_approx, sigmoid_approx, tanh_approx, fmadd Bulk helpers: map_relu, map_relu6, map_sigmoid, map_gelu, map_tanh Reductions: v8f_reduce_sum, v8f_reduce_max, v8f_reduce_min BLAS-style: dot_product, axpby, scale_inplace
55 functions detected.
std module: common prelude for TezzNative Import core libraries so projects can just `import "std"` as a baseline.
12 functions detected.
str module — comprehensive string utilities for TezzNative All functions return heap-allocated strings that must be free()'d, unless documented otherwise. Null/empty inputs are handled gracefully.
43 functions detected.
stt module — TezzNative 2.0 Native Speech-to-Text Engine Bundled Whisper-style inference engine for speech recognition. No OS API dependencies. Uses nn.tn for model inference. Architecture: 1. Audio capture from microphone (WAV input or raw PCM) 2. Mel spectrogram extraction (80-channel mel filterbank) 3. Log-mel feature normalization 4. Encoder: Conv + Transformer (via nn.tn) 5. Decoder: autoregressive token prediction 6. Token → text via tokenizer Usage: stt:*SttEngine = stt_new() stt_load_model(stt, "whisper-tiny.tnw") // TezzNative weight format text:str = stt_from_file(stt, "audio.wav") text2:str = stt_from_mic(stt, 5000) // record 5 seconds stt_free(stt)
18 functions detected.
supervisor.tn — Erlang/Elixir OTP Supervisor Tree Engine for TezzNative Implements "Let It Crash" fault-tolerance architecture. Stores supervisor state and logs cleanly inside `.log/` subfolder.
5 functions detected.
sys module: freestanding ABI surface (no stdlib) NOTE: These are stubs/signatures for low-level targets. Backends/targets can map them to platform syscalls or kernel services.
12 functions detected.
task module: minimal async/await wrappers (native runs concurrently; VM runs synchronously)
8 functions detected.
tensor module: Advanced SIMD-accelerated math for AI and Neural Networks. This module provides the foundational core for building LLMs and deep learning frameworks (like TezzAI) on top of TezzNative. It leverages heavily unrolled, SIMD-optimized math kernels.
30 functions detected.
Core SDK module.
2 functions detected.
Core SDK module.
20 functions detected.
test module — testing assertions and test runner for TezzNative Stability: Beta Depends: runtime Usage: import "test" suite:*TestSuite = test_new("my tests") test_assert_eq_int(suite, "add works", add(2, 3), 5) code:int = test_run(suite) test_free(suite)
22 functions detected.
tezz_http_server.tn — Enterprise Production HTTP Web Server & Streaming Engine Key Architecture: • High-Performance Zero-RAM Streamer (`stream_file_response`): Streams GB, TB, PB files in 64 KB chunks via heap malloc(65536) with constant 64 KB memory overhead. • 100% Fault-Tolerant Execution: Safe memory model with zero invalid free() operations. • Erlang/Elixir-style OTP Concurrency & Supervisor Tree Engine (supervisor.tn). • "Let It Crash" Fault Tolerance with Automatic Worker Recovery. • Isolated `.log/` Directory Storage for process locks and server status. • Location-agnostic Any-Directory hosting (CWD bound). • Dynamic Port Binding via CLI argument (e.g. `tezz serve 8084`). • Production OTP Authentication REST API (/api/otp). • Embedded TezzDB REST/JSON API endpoint (/api/db). • 100% Binary Stream Integrity for JPEG, PNG, WEBP, PDF, ZIP, MP4, WASM, DB. • Comprehensive 70+ MIME Type Map.
17 functions detected.
tezzapi module — TezzNative 2.0 Full Backend API Framework Production-grade HTTP REST API engine built on TezzNative networking. Supports: GET / POST / PUT / PATCH / DELETE / HEAD / OPTIONS Features: • Path parameters: /users/:id → api_param(req, "id") • Query string parsing: ?page=2&limit=50 • JSON request body parsing • File upload (multipart/form-data) • Middleware chain (pre/post hooks) • Response builder with status codes and headers • WebSocket upgrade handler • CORS helper • Rate limiting per IP • JWT-style bearer token validation • TNXB binary protocol (fast native clients)
127 functions detected.
tezzdb module — TezzNative 2.0 Native Database Engine TezzDB is a fully native, high-performance embedded database written entirely in TezzNative. No external dependencies. Architecture: • Page-based storage: 8192-byte (8KB) pages • B+ Tree index: all data in leaf pages, O(log n) lookup • Multiple tables per database file • BLOB-safe: stores raw byte data, JSON, or binary • Write-Ahead Log (WAL): append-only crash recovery log • ACID Transactions: begin/commit/rollback • Auto-increment primary keys • Secondary indexes: by any string column • Query: by PK, by indexed column, or full scan • Connection-style API: open/close/query/insert/update/delete • Native TezzNative UI bridge: JSON row format Page layout (8192 bytes): [0..3] page_type (u32 LE) [4..7] page_id (u32 LE) [8..11] next_page (u32 LE) — 0 = none [12..15] count (u32 LE) — keys/rows in this page [16..] payload Page types: 0 = DB_PAGE_FREE 1 = DB_PAGE_HEADER 2 = DB_PAGE_BTREE_INTERNAL 3 = DB_PAGE_BTREE_LEAF 4 = DB_PAGE_OVERFLOW
110 functions detected.
tezzdbql module — TezzNative 2.0 SQL-like Query Language TezzDBQL provides a SQL-inspired query interface on top of the native TezzDB B+ tree engine. Supported syntax (subset): SELECT * FROM table [WHERE col = ?] [LIMIT ?] INSERT INTO table (col1, col2, ...) VALUES (?, ?, ...) UPDATE table SET col1 = ? [WHERE id = ?] DELETE FROM table [WHERE id = ?] Parameterized queries use "?" placeholders. Results are accessed through a cursor-like QueryResult. Usage: import "../lib/tezzdb.tn" import "../lib/tezzdbql.tn" db:*char = db_open("mydb.db") db_table_create(db, "users") params:[str;4] params[0] = "alice" params[1] = "alice@example.com" r:*TzQueryResult = db_query(db, "INSERT INTO users (name, email) VALUES (?, ?)", ¶ms[0], 2) db_result_free(r) r2:*TzQueryResult = db_query(db, "SELECT * FROM users WHERE name = ?", ¶ms[0], 1) while db_result_next(r2) != 0: say cursor_field_str(r2, "name"), cursor_field_str(r2, "email") db_result_free(r2)
43 functions detected.
lib/tezzinstall.tn TezzNative Installer Framework v1.0 Create self-describing Windows installers entirely in TezzNative. Uses tezzui for the visual interface + PowerShell/Win32 for file operations. Usage example: import "tezzinstall" let cfg:TzInstall tezzinstall.install_set_name(&cfg, "MyApp") tezzinstall.install_set_version(&cfg, "1.0.0") tezzinstall.install_set_exe(&cfg, "MyApp.exe") tezzinstall.install_run(&cfg)
24 functions detected.
tezzserve module: production API server framework on top of TezzApi. Goals in v1.0: - Fast route registration helpers for API servers - Hardened HTTP session lifecycle wrappers - TNXB bridge endpoint helpers (HTTP body -> TNXB decode -> route dispatch)
64 functions detected.
tezzsetup module: production installer/uninstaller core logic for TezzNative. This module intentionally keeps the operational logic separate from GUI code, so we can validate install/uninstall behavior in headless CI and reuse it from Tk-style GUI frontends.
14 functions detected.
tezzspeech module: local TezzSpeech IPC protocol (no HTTP). Transport: - TCP loopback service (default 127.0.0.1:8097) - Binary framed protocol for low-latency request/response. Frame layout (12-byte header + payload): [0..3] magic "TZS1" [4] version (1) [5] op [6] status (response only; request uses 0) [7] reserved [8..11] payload_len (u32 little-endian) Payload for SPEAK: lang=<lang>\n voice=<voice>\n rate=<int>\n clone=<voice_ref_path>\n trace=<request_id>\n \n <text>
59 functions detected.
Core SDK module.
24 functions detected.
tezzui.tn — TezzNative Production UI Library v1.2 Immediate-mode widgets — no OS imports, pure gui_win bridge.
60 functions detected.
time module: sleep + time/date helpers
14 functions detected.
tkui module (deprecated): use tzui instead. Goals: - Keep app code short and readable (window/frame/label/button/entry) - Use dirty-region rendering by default via tzgui tree - Provide basic pointer + keyboard interaction for installer-style apps
30 functions detected.
tls module: OS-backed TLS/HTTPS helpers
17 functions detected.
Core SDK module.
26 functions detected.
tnui module: canonical retained GUI API for TezzNative. Thin wrapper over tzui so apps can migrate to `tnui` naming.
37 functions detected.
TezzNative eXchange (TNX): JSON-like data encoding for payloads and storage. Types: null, bool, int, float, string, array, object. Memory: all returned values/strings are heap-allocated; call tnx.release().
88 functions detected.
tokenizer module — TezzNative 2.0 Native BPE Tokenizer Byte-Pair Encoding tokenizer compatible with GPT-2/GPT-NeoX merges. Features: • Load vocab and merges from JSON files • Encode text → int array of token IDs • Decode token IDs → UTF-8 string • Byte-level fallback for unknown chars • Special tokens: <|endoftext|>, <pad>, <unk> • Efficient cache for repeated encodings • SentencePiece-style whitespace prefix • Token count (no allocation) for length estimation Usage: tok:*Tokenizer = tokenizer_load("vocab.json", "merges.txt") ids:*int = tokenizer_encode(tok, "Hello World!") n:int = tokenizer_last_encode_len(tok) text:str = tokenizer_decode(tok, ids, n) tokenizer_free(tok)
25 functions detected.
============================================================ trainer.tn — TezzMind On-Device Training Engine v4.0 (AVX2) ============================================================
25 functions detected.
tsm module: TezzServiceManager (cross-platform service/process control scaffold). Registry format: TNX array of service objects. Service object keys: - name:str - cmd:str - cwd:str - autostart:int (0/1) - restart:int (0=never,1=always) - enabled:int (0/1)
29 functions detected.
tts module — TezzNative 2.0 Native Text-to-Speech Engine Bundled neural TTS inference — no OS API dependencies. Also provides lightweight rule-based fallback for fast speech. Architecture: 1. Text normalization (numbers, abbreviations, punctuation) 2. Phoneme conversion (letter-to-sound rules + exception dict) 3. Prosody: stress, intonation, duration models 4. Neural vocoder (Griffin-Lim or WORLD-style spectral synthesis) 5. WAV/PCM output to file or speaker via OS audio API Usage: tts:*TtsEngine = tts_new() tts_speak(tts, "Hello, world!") // play via speaker tts_speak_to_file(tts, "hi.wav", "Hello") // save WAV tts_set_voice(tts, "en-US-female") tts_set_rate(tts, 1.2) tts_set_pitch(tts, 0.9) tts_free(tts)
30 functions detected.
lib/tzautodiff.tn -- TezzNative Dynamic Autograd Tape Engine v2.2 PyTorch-style Automatic Differentiation Tape & Computation Graph. Records operations during forward pass and propagates gradients in reverse topological order.
7 functions detected.
lib/tzcheckpoint.tn -- TezzNative Model Checkpoint v1.0 Save and load model weights in the TZKP binary format. Usage: import "tzcheckpoint" tzcheckpoint.save("model.tnck", ptrs_buf, sizes_buf, names_buf, n) n: int = tzcheckpoint.load("model.tnck", ptrs_buf, sizes_buf, -1) tzcheckpoint.info("model.tnck") ptrs_buf: int buffer of int64 pointers to float32 weight arrays sizes_buf: int buffer of int64 element counts per weight names_buf: int buffer of int64 pointers to name strings
8 functions detected.
lib/tzcpu.tn -- TezzNative CPU Backend v2.1 Portable CPU fallback for when no CUDA GPU is present. Runs on: x86-64 (Windows/Linux), ARM64 Snapdragon (Windows on ARM, Linux ARM64) 63 highly-optimized SIMD / OpenMP kernels: - Memory & element-wise - Activations & normalizations (ReLU, GELU, Sigmoid, Tanh, Softmax, LayerNorm, RMSNorm) - Linear algebra & GEMM (gemm, gemm_nt, gemm_tn, bmm, int8_gemm) - Vision CNNs (conv2d, conv2d_bwd, maxpool2d) - Transformers & LLMs (embedding, attention, rope, kv_cache_update, masked_softmax) - Sampling & Generation (argmax, topk, sample) - Optimizers (adam, sgd, grad_clip, xavier_init) - Loss & Metrics (cross_entropy, mse_loss, get_loss, report_loss) - Quantization & FP16 (f32_to_f16, f16_to_f32, int8_gemm) - Diagnostics & Validation (print_tensor, check_finite)
126 functions detected.
lib/tzgguf.tn -- TezzNative GGUF Binary Model Loader & Quantization Engine v2.2 Zero-dependency direct reader and dequantizer for .gguf quantized neural networks.
27 functions detected.
lib/tzgpu.tn -- TezzNative GPU Library v2.0 (Production) Low-level bridge between Tezz and CUDA kernels in tzgpu.dll f32 primary (4x faster on RTX 3060 sm_86), f64 kept for compatibility. Remote tezzc rules: - Qualified access only: tzgpu.function_name - Redeclare constants locally (qualified import doesn't expose them) - Block-form if/else only Usage: import "tzgpu" dev: int = tzgpu.gpu_malloc_f32(1024) // 1024 floats on GPU tzgpu.gpu_free(dev)
78 functions detected.
tzgui module: production-oriented, low-boilerplate GUI engine helpers. Built on top of core `gui` + `frame` primitives. Goals: - Easy app code (few calls to get a windowed UI) - Damage-aware redraw requests (apps mark what changed) - Deterministic behavior for freestanding/framebuffer targets
46 functions detected.
tzgui_native module — TezzNative 2.0 Host Native Windowing Backend Wraps GDI/Win32/Cocoa/X11 and provides unified cross-platform TzWindow, mouse, keyboard, and event loop.
6 functions detected.
tzimage: compact image kernels for TezzNative. Focus: simple RGB/RGBA image operations with low-overhead memory handling.
25 functions detected.
lib/tzllm.tn -- TezzNative LLM Transformer Engine v2.2 Features: 1. Multi-Head Attention Q, K, V head extraction via 4D Tensor Slicing 2. Rotary Position Embeddings (RoPE) via Split-Half Slicing 3. Sliding-Window KV-Cache with dynamic sub-tensor context slicing 4. RMSNorm Pre-Normalization & Causal Masked Softmax 5. Autoregressive Generation with Top-p / Top-k Nucleus Sampling
4 functions detected.
lib/tzmnist.tn -- TezzNative MNIST DataLoader v1.0 Loads the official MNIST IDX binary format dataset. Download dataset from: http://yann.lecun.com/exdb/mnist/ Usage: import "tzmnist" ds: int = tzmnist.load("data/mnist", "train") // or "test" n: int = tzmnist.n_samples(ds) tzmnist.shuffle(ds, 42) // Training loop: x_buf: int = tz_cpu_malloc(batch * 784 * 4) y_buf: int = tz_cpu_malloc(batch * 4) tzmnist.next_batch(ds, x_buf, y_buf, batch) tzmnist.reset(ds) tzmnist.free(ds)
18 functions detected.
lib/tznn.tn -- TezzNative Neural Network Library v1.0 High-level NN API: Dense, ReLU, GELU, Softmax, LayerNorm, Dropout, Embedding, Sequential model, cross-entropy loss, Adam optimizer. Architecture: tznn.tn (this file) -- layer API, Sequential model → tzgpu.tn -- low-level CUDA wrappers → tzgpu_kernels.cu -- RTX 3060 sm_86 CUDA kernels All tensors are f32 device pointers (int) unless noted. Shapes are passed explicitly (no dynamic shape tracking yet). Usage example: import "tznn" model: int = tznn.nn_model_create(4) // max 4 layers tznn.nn_model_add_dense(model, 784, 128) // layer 0 tznn.nn_model_add_relu(model, 128) // layer 1 tznn.nn_model_add_dense(model, 128, 10) // layer 2 tznn.nn_model_add_softmax(model, 10) // layer 3 out: int = tznn.nn_model_fwd(model, x, batch, 784) tznn.nn_model_free(model)
58 functions detected.
tznum: compact numeric kernels for TezzNative Focus: concise, NumPy-style core operations without runtime overhead.
40 functions detected.
lib/tzoptim.tn -- TezzNative High-Level Optimizer Suite v2.1
6 functions detected.
lib/tzsafetensors.tn -- TezzNative HuggingFace Safetensors Model Weight Loader v2.2 Zero-dependency direct reader for .safetensors binary files into tztensor.Tensor instances.
12 functions detected.
lib/tztensor.tn -- TezzNative First-Class Tensor System v2.2 High-performance, unified-device tensor operations wrapping native SIMD & CUDA kernels.
49 functions detected.
lib/tztokenizer.tn -- TezzNative HuggingFace BPE Tokenizer Wrapper v2.2 High-level text encoding and decoding interface.
11 functions detected.
tzui module: TzUI-style retained GUI wrapper over tzgui. Goals: - Keep app code short and readable (window/frame/label/button/entry) - Use dirty-region rendering by default via tzgui tree - Provide basic pointer + keyboard interaction for installer-style apps
48 functions detected.
vec module — type-erased dynamic array (growable slice) All elements have the same size (elem_size). Use unsafe blocks to read/write typed elements. Usage: v:*Vec = vec_new(sizeof(int)) val:int = 42 vec_push(v, &val as *char) got:int = 0 vec_get_copy(v, 0, &got as *char) vec_free(v)
34 functions detected.
wm module: compositor-style host window management lane. Features: - Multiple managed windows with z-order and focus. - Pointer-driven title-bar dragging. - Keyboard dispatch to focused window callbacks. - Explicit lifecycle operations (create/show/move/resize/remove).
28 functions detected.
