Ultra-Fast Systems.
Native Deep Learning.
Engineered for Hardware.
A premier systems and AI programming language created by Rohit Pathak at TezzCorp Pvt Ltd. Compiling directly to zero-overhead standalone native executables with first-class tensor arithmetic, multi-threaded async/await, and scoped memory safety without garbage collection pauses.
iwr https://tn.tezzcorp.com/download/TezzNativeInstaller.exe -OutFile setup.exe; .\setup.exe
tezz init my-ai-project && cd my-ai-project
tezz mod add tztensor tzautodiff task net
tezz build --release
Engineered for Raw Bare-Metal Speed
TezzNative compiles directly into native CPU machine instructions (AVX2, FMA, NEON) with zero garbage-collection pauses and zero interpreter overhead.
Experience the Syntax in Action
Explore interactive code examples showcasing native async coroutines, deep learning autograd, GGUF binary loading, and scoped memory cleanup.
// Native Async/Await Concurrency in TezzNative import "task" import "net" async fn fetch_user_profile(uid: int) -> int: let client = net.http_client() defer client.close() let res = client.get("https://api.tezzcorp.com/v1/user") ret res.status_code fn main() -> int: say "Spawning concurrent async worker tasks..." let t1 = task.spawn_arg(fetch_user_profile, 101) let t2 = task.spawn_arg(fetch_user_profile, 102) // Native non-blocking join on event loop let s1: int = await t1 let s2: int = await t2 say "Task 1 HTTP status:", s1 say "Task 2 HTTP status:", s2 ret 0
Designed for the Next Decade of Computing
TezzNative eliminates the historic divide between rapid Python prototyping and low-level C systems programming.
Pythonic Indentation & Static Types
Write elegant indentation-based code that feels effortless to read, while enjoying compile-time type safety, exhaustive pattern matching, and zero runtime type tags.
fn fib(n: int) -> int:
if n <= 1: ret n
ret fib(n-1) + fib(n-2)
Native Async / Await Coroutines
Spawn hardware-threaded async workers and await asynchronous I/O and matrix compute non-blockingly on an integrated event loop with zero function-color baggage.
let task: AsyncTask = task.spawn_arg(worker, 42)
let result: int = await task
First-Class Matrix Ops & Infix @
Tensors are first-class language constructs. Execute matrix multiplications with the infix @ operator, slice 4D tensor volumes seamlessly, and backpropagate with automatic differentiation.
let H = (X @ W1).relu()
let slice = tensor[0, 1, 10:20, 10:20]
Deterministic Scoped 'defer'
Resource handles, sockets, files, and CUDA contexts are automatically released in LIFO reverse order upon scope exit. Zero garbage collection pauses, zero memory leaks.
let f = io.open("data.bin", "rb")
defer f.close() // Executed on exit
Zero-Dependency Native Binaries
Compile single standalone Windows PE .exe or Linux ELF binaries that require zero runtime installs, zero dynamic interpreters, and start in under 1 millisecond.
tezzc buildexe main.tn app.exe
# Outputs standalone native binary
Native Language Server (LSP)
Official LSP v3.17 daemon (tezz_lsp.exe) brings hover documentation, Go to Definition, auto-completion, and real-time syntax checking to VS Code, Neovim, Zed, and Cursor.
tezzc lsp # Starts standard stdio JSON-RPC daemon
Zero-Config IDE Integration
TezzNative includes a first-party Language Server Protocol daemon (tezz_lsp) built directly in TezzNative. Enjoy rich IDE features with zero configuration across your favorite code editor.
import "tztensor"
import "tzautodiff"
fn forward_pass(x: Tensor, w: Tensor):
let y_hat = (x @ w).relu()
ret y_hatStart Building with TezzNative Today
Join developers creating high-throughput AI backends, native desktop GUIs, and zero-overhead systems software.