Routes without framework ceremony
Functions and typed responses make small web applications readable without a VM or application framework in production.
A native language for the web
Web code,
forged to native.
Vonk turns direct, readable web applications into freestanding Linux binaries—through its own frontend, verified stack IR, instruction encoders and ELF64 writer.
NO LLVMNO GO BACKENDNO EXTERNAL LINKER
● source-owned pipeline
● Linux ELF64
3native targets: amd64, ARM64 and RV64
61compiler and native execution test methods
0external app toolchain processes during vonk build
Why Vonk exists
Simple web code.
The whole stack owned.
Vonk gives web applications a clear language surface and a transparent path from source code to a native executable.
Direct instruction encoding
The compiler emits x86-64, AArch64 and RV64 instructions itself—no textual assembly or hidden LLVM phase.
Bounded by design
Source graphs, JSON, HTTP, memory, recursion and external capabilities have explicit limits and deterministic failures.
record User { name: string, active: bool }
fn greeting(user: User) -> string {
return "Hello, " + user.name + "!";
}
route GET "/hello" {
const user = User("Ada", true);
return text(greeting(user));
}✓ Built native ELF64 · no external app toolchain
Familiar surface, native core
Readable like a script.
Checked like a language.
Vonk combines direct route definitions with static types and deterministic native output. Values are immutable by default; external authorities cannot be copied accidentally.
- ✓ Records, lists, optionals and typed results
- ✓ Int64 and IEEE-754 binary64 operations
- ✓ Local modules and versioned packages
- ✓ Source-aware runtime diagnostics
A complete vertical slice
More than a compiler
demo.
The runtime is authored in Vonk and compiled through the same backend as application code. These capabilities execute today.
Three machine-code backends
Own encoders for Linux amd64, ARM64 and RV64IMD, with checked branches, PIE addressing and W^X segments.
Typed JSON
Bounded validation, escaping and typed field extraction.
PostgreSQL
Native extended wire protocol, parameters and transactions.
Native web responses
Typed text, HTML, JSON and errors, strict routes, static ranges, ETags and gzip sidecars.
Capability-rooted files
Bounded workspace reads and atomic writes with traversal and symlink protection.
ACME + OpenSSL edge
Native Let's Encrypt issuance and a fast, bounded public TLS frontend.
Language-aware tooling
Formatter, language server, IR inspection, address maps, ELF symbols and a GDB workflow.
Explicit memory and ownership
Bounded arena storage, immutable handles and affine database/workspace capabilities.
The application model
Fast to write.
Native to run.
Vonk brings language, runtime and deployment into one coherent product: typed source enters; a focused Linux executable comes out.
Application code
HTTP entry pointCompiled
route GETStructured dataTyped records and lists
Optional state
optional<T>Recoverable failureTyped
T! result and ?HTTP outputTyped response helpers
Native foundation
RuntimeFreestanding Linux ELF64
Code generationOwn x64, A64 and RV64 encoders
DatabaseNative PostgreSQL wire client
MemoryBounded arena and immutable handles
Production TLSOpenSSL edge, localhost app
A focused foundation, growing deliberately. POST bodies, templates, authentication, sessions, remote database TLS/SCRAM, async I/O and HTTP/2 remain explicit roadmap items.
The compiler pipeline
No black box between
source and ELF.
A C11 bootstrap builds the compiler. Application builds then stay inside Vonk's frontend, verifier, encoders and executable writer.
01Lexer + parsertyped AST
02Package graphlocal + deterministic
03Stack IRverified control flow
04Native encoderx64 / A64 / RV64
05ELF64 writerPIE + W^X
Live native runtime
This page is the
running showcase.
Each action calls a route in the same generated Linux executable that assembled this page. Try text, recursion, typed JSON and an HTTP error.
$ curl /api/health
Select an operation to execute real Vonk code.
Production transport
Fast TLS.
Native app.
The public edge delegates mature cryptography to OpenSSL, then forwards a bounded HTTP/1.1 request to the freestanding application on localhost.
- ✓ Millisecond-class TLS handshakes
- ✓ App remains an own-machinecode ELF
- ✓ Fixed 127.0.0.1 trust boundary
InternetHTTPS :443
→vonk-tlsOpenSSL · ALPN · bounds
→Vonk app127.0.0.1:8080 · ELF64
PUBLIC TRANSPORT → MATURE CRYPTO → PROCESS-ISOLATED ROUTES
Support and documentation
Understand the code.
Build with confidence.
The documentation explains both the approachable language surface and the native machinery underneath it—from your first function to deployment behind the OpenSSL edge.
Read Vonk code
Learn declarations, static types, control flow, records, immutable lists and optionals.
Language essentials →Serve a route
Return text, HTML, validated JSON or explicit errors from compiled route handlers.
Web guide →Cross boundaries
Use bounded JSON, PostgreSQL parameters and capability-rooted file operations.
Data and I/O →Operate safely
Build for three targets, run checks, terminate TLS and inspect native binaries.
Deployment guide →Built honestly
A working foundation,
not a finished platform.
Vonk separates implemented behaviour, structural checks and executed evidence. The roadmap favours demonstrable correctness over broad claims.
Native foundation
- Own amd64, ARM64 and RV64 backends
- Typed values, modules and recoverable errors
- JSON, PostgreSQL and capability-rooted I/O
- HTTP, static assets, ACME and OpenSSL edge
- Formatter, LSP, symbols and debugger workflow
Complete application platform
- Self-hosted parser, IR and ELF emission
- POST bodies and contextual templates
- Authentication, sessions and authorization
- Remote database TLS/SCRAM and pooling
- Async I/O, WebSockets, metrics and HTTP/2
Start with the source
Read the pipeline.
Build the compiler.
Light the spark.
make build && ./bin/vonk build examples/hello.vonk -o build/helloExperimental · open source · built without a hidden application backend