Written in Koder Lang

Meet Jet

A fast, minimal, batteries-included web server. Auto HTTPS, multi-protocol, and expressive routing -- all in one binary.

server.kd
import jet

app = jet.new()

app.get "/" do |ctx|
  ctx.json { message: "Hello from Koder Jet!" }
end

app.listen 3000

Everything you need, nothing you don't

Koder Jet ships with production-ready features out of the box. No plugins to install, no dependencies to manage.

Auto HTTPS

Automatic TLS certificates via ACME. Zero-config HTTPS with automatic renewal and OCSP stapling.

HTTP/1.1, HTTP/2 & HTTP/3

Full multi-protocol support including QUIC-based HTTP/3 for ultra-low latency connections.

Middleware Pipeline

Composable middleware stack with before/after hooks, error recovery, CORS, rate limiting, and auth.

Reverse Proxy & Load Balancer

Built-in reverse proxy with round-robin, least-connections, and weighted load balancing strategies.

WebSocket & SSE

First-class WebSocket and Server-Sent Events support with automatic upgrade negotiation.

Radix Tree Router

High-performance radix tree routing with O(k) lookups, parameterized paths, and wildcards.

gRPC

Native gRPC server and client with protobuf support, streaming, and automatic service reflection.

OpenAPI Auto-Gen

Automatically generates OpenAPI 3.1 specs from your route definitions. Swagger UI included.

Template Engine

Built-in template engine with layouts, partials, and hot-reload in development mode.

Response Cache

In-memory and Redis-backed response caching with stale-while-revalidate and cache tags.

Prometheus Metrics

Built-in /metrics endpoint with request latency histograms, status codes, and custom counters.

Paradox

Run up to 9 app versions simultaneously. Cookie-based routing, instant switching with Alt+1..9, zero downtime.

Auto-Update

Cron-scheduled self-update with zero downtime. Health check verification and automatic rollback if the new version fails to start.

Expressive, readable, powerful

Koder Lang's Ruby-like syntax makes route definitions feel natural. Write less, serve more.

REST API with middleware
import jet
import jet/middleware

app = jet.new()

# Global middleware
app.use middleware.logger
app.use middleware.cors origin: "*"
app.use middleware.rate_limit 100, "1m"

# Route group with auth
app.group "/api/v1" do
  use middleware.jwt_auth secret: env("JWT_SECRET")

  get "/users" do |ctx|
    users = User.all
    ctx.json users
  end

  post "/users" do |ctx|
    user = ctx.body_as User
    user.save!
    ctx.status(201).json user
  end

  get "/users/:id" do |ctx|
    user = User.find ctx.param("id")
    ctx.json user
  end
end

app.listen 3000
WebSocket + SSE
import jet

app = jet.new()

# WebSocket chat
app.ws "/chat" do |ws|
  ws.on_message do |msg|
    ws.broadcast msg
  end

  ws.on_close do
    puts "Client disconnected"
  end
end

# Server-Sent Events
app.sse "/events" do |stream|
  loop do
    data = fetch_updates
    stream.send event: "update",
                   data: data.to_json
    sleep 1
  end
end

# Reverse proxy with load balancing
app.proxy "/api/*" do
  upstream "http://10.0.0.1:8080", weight: 3
  upstream "http://10.0.0.2:8080", weight: 1
  strategy :weighted
  health_check "/health", interval: "10s"
end

app.listen 3000

How Koder Jet stacks up

A feature-by-feature comparison against popular web servers and frameworks.

Feature Koder Jet Nginx Caddy Traefik Express Actix Web
Language Koder Lang C Go Go JavaScript Rust
Auto HTTPS Yes No Yes Yes No No
HTTP/3 (QUIC) Yes Exp. Yes Yes No No
Reverse Proxy Yes Yes Yes Yes Plugin No
Load Balancer Yes Yes Yes Yes No No
WebSocket Yes Proxy Proxy Proxy Plugin Yes
gRPC Yes Proxy Proxy Proxy No Plugin
OpenAPI Gen Yes No No Yes Plugin No
Template Engine Built-in No Yes No Plugin Plugin
Response Cache Built-in Yes No No No No
Prometheus Metrics Built-in Module Yes Yes Plugin Plugin
Single Binary Yes No Yes Yes No Yes
Multi-Version Routing Paradox No No Canary No No
Config Format TOML + Code Custom Caddyfile/JSON TOML/YAML Code Code

The kjet command

Manage your server, inspect routes, and benchmark performance from the terminal.

kjet serve
$ kjet serve --port 3000 --tls auto

  Koder Jet v1.1.3
  Listening on https://0.0.0.0:3000
  TLS certificate obtained for jet.koder.dev
  HTTP/3 (QUIC) enabled
  Press Ctrl+C to stop
kjet routes
$ kjet routes

  METHOD  PATH              HANDLER         MIDDLEWARE
  GET     /                 index           logger, cors
  GET     /api/v1/users     users#index     logger, cors, jwt
  POST    /api/v1/users     users#create    logger, cors, jwt
  GET     /api/v1/users/:id users#show      logger, cors, jwt
  WS      /chat             chat#connect    logger
  SSE     /events           events#stream   logger
  PROXY   /api/*            upstream[2]     logger
kjet bench
$ kjet bench http://localhost:3000 -c 200 -d 10s

  Benchmarking http://localhost:3000...
  200 connections, 10s duration

  Requests/sec:   148,392
  Avg latency:    1.34ms
  P99 latency:    4.21ms
  Transfer/sec:   42.8 MB
  Total requests: 1,483,920
  Errors:         0 (0.00%)

TOML-based config

Configure your server declaratively with TOML, or programmatically in Koder Lang. Both approaches work together.

jet.toml
# Koder Jet configuration

[server]
host = "0.0.0.0"
port = 3000
workers = "auto"  # matches CPU cores

[tls]
auto = true
domains = ["jet.koder.dev"]
acme_email = "admin@koder.dev"

[http3]
enabled = true

[cache]
enabled = true
max_size = "256MB"
default_ttl = "5m"

[metrics]
enabled = true
path = "/metrics"

[logging]
level = "info"
format = "json"
Reverse proxy config
# jet.toml - reverse proxy mode

[server]
port = 443

[tls]
auto = true

[[proxy]]
match = "api.example.com"
to = [
  "http://10.0.0.1:8080",
  "http://10.0.0.2:8080",
]
strategy = "round_robin"
health_check = "/health"

[[proxy]]
match = "app.example.com"
to = ["http://localhost:5000"]

[[proxy]]
match = "grpc.example.com"
to = ["h2c://localhost:50051"]
protocol = "grpc"

Paradox

Run up to 9 versions of the same app behind a single domain. Cookie-based routing, instant switching, zero downtime. The name reflects the contradictory coexistence of multiple versions serving the same URL.

How it works

1
Slot registration — Each version runs on its own port. Define slots in sites.toml under [sites.paradox].
2
Cookie routing — Jet reads the _paradox cookie and routes to the matching slot. No cookie = default (slot 0).
3
JS injection — A tiny snippet is injected into HTML responses: a 6px colored dot and Alt+1..9 shortcuts.
4
Instant switch — Press Alt+N to set the cookie and reload. Session preserved, version changes instantly.

Use cases

Instant Rollback

Press Alt+1 to go back to production. No restart needed.

Side-by-Side QA

Compare versions in two tabs — same URL, different backends.

Canary Deploys

Route a subset of users to the new version via cookie.

Zero Downtime

Add a new slot, switch when ready. Old version keeps running.

sites.toml — Paradox config
[[sites]]
domains = ["myapp.koder.dev"]
proxy   = "http://localhost:3100"
gzip    = true

[sites.paradox]
enabled = true
cookie  = "_paradox"   # optional, default
slots   = [
  { port = 3100, name = "prd" },
  { port = 3101, name = "dev" },
  { port = 3102, name = "staging" },
]
Architecture
Browser Request
    
    ├─ Cookie: _paradox=1  ──→  Slot 1 (port 3100, prd)
    ├─ Cookie: _paradox=2  ──→  Slot 2 (port 3101, dev)
    ├─ Cookie: _paradox=3  ──→  Slot 3 (port 3102, staging)
    ├─ No cookie           ──→  Slot 0 (default, prd)
    
    └─ Response: HTML + injected JS
         ├─ 6px colored dot (bottom-right)
         └─ Alt+1..9 keyboard listener

Install Koder Jet

One binary. Zero dependencies. Production-ready in seconds.

Quick Install

Install via the Koder package manager or curl.

$ koder install jet

# or via curl
$ curl -fsSL https://jet.koder.dev/install.sh | sh

Latest Release

Download pre-built binaries for your platform.

Benchmarks

9 real-world tests against Caddy and Nginx. Production Rails + PostgreSQL backend, 112-core server. Jet wins 8 of 9 tests.

10–63x
Faster Proxy
107µs
Min Latency (p50)
13ms
Cold Start
29.0 MB
Memory (RSS)

1Reverse Proxy

Real application backend: Ruby on Rails + PostgreSQL 18.3

ConnectionsJet rpsJet p50Caddy rpsNginx rpsΔ
5024,6791.52ms2,4372,486+893%
50047,0995.37ms2,2192,630+1,691%
Koder Jet
47,099 rps
Nginx
2,630
Caddy
2,219

2Static File Serving

Direct file serving at 200 concurrent connections

File SizeJet rpsCaddy rpsNginx rpsWinner
1 KB35,923101,405244,905Nginx (6.8x)
100 KB35,49248,15351,792Nginx (1.5x)
1 MB36,4705,1065,275Jet (7x)
For small/medium files, Nginx wins with kernel-level sendfile(). For large files (1MB+), Jet's buffered I/O outperforms both. A dedicated sendfile path is planned for Jet.

3Large Response Body

160KB HTML page at 200 concurrent connections

JetCaddyNginx
Requests/sec36,50032,90535,631
p50 latency3.33ms3.14ms2.78ms

4Concurrent Scaling

How throughput scales from 10 to 1,000 simultaneous connections

ConnectionsJet rpsCaddy rpsNginx rpsJet Δ
1024,127357379+6,264%
5027,164755797+3,310%
10031,262765778+3,917%
20037,267772813+4,486%
50048,106783815+5,801%
1,00050,626726802+6,214%
Jet 10c
24,127
Jet 100c
31,262
Jet 500c
48,106
Jet 1000c
50,626
Nginx 1000c
802
Caddy 1000c
726

5Low-Load Latency

Minimum proxy overhead with 1 and 5 connections

ConnectionsJet p50Jet p99Caddy p50Nginx p50Jet rps
1107µs396µs4.16ms3.85ms8,052
5264µs598µs4.65ms4.69ms14,918
With just 1 connection, Jet adds only 107 microseconds of proxy overhead. Caddy and Nginx add 4ms+ — 36x more latency.

6Upload (POST 10KB)

POST requests with 10KB payload at 200 concurrent connections

JetCaddyNginx
Requests/sec36,8471,8172,096
p50 latency3.31ms10.24ms12.89ms
Errors0714 timeouts0

7Cold Start

Time from process start to first HTTP response

13ms
Koder Jet
44ms
Nginx
140ms
Caddy

8Keep-Alive Sustained (60s)

Stability over 60 seconds with 50 persistent connections

JetCaddyNginx
Requests/sec27,234768798
p50 latency1.33ms29.38ms28.68ms
p99 latency9.32ms440ms416ms

9Memory Usage

RSS memory footprint

Koder Jet
29.0 MB
Caddy
43.9 MB
Nginx
187.1 MB
Jet uses 34% less memory than Caddy and 85% less than Nginx (including all worker processes).

Environment: r1 (32 cores, 256 GB RAM, LXC on Proxmox) · Debian 12 · Koder Jet v1.11.0, Caddy v2.6.2, Nginx 1.22.1

Backend: Ruby on Rails + PostgreSQL 18.3 on localhost:3100 · wrk 4.1.0, 15s per test, 3s warmup

Config: Pure HTTP reverse proxy, no TLS, no caching, no compression — measures only proxy overhead · Last run: 2026-04-08

Ready to get started?

Try Koder Jet - Fast, Minimal, Batteries-Included Web Server today.