AOT-compiled, LLVM-backed programming language

AOT · LLVM 18 · batteries included

Build anythingwithout the boilerplate

As easy as Python, as fast as C. A statically-typed, AOT-compiled language with HTTP, JSON, SQLite, an ORM, OpenAPI, and C FFI built right into the runtime — no npm install, no pip, no dependencies.

Get Started →Open PlaygroundView on GitHub ↗

~36kreq/s · Tulpar pool

~1.9× Cfib · native AOT

0external dependencies

🌐 Web API 🛠️ CLI Tool 📊 Data Processing

running

api.tpr

import "wings";
import "orm";

orm_open("app.db");
define_model("users", {
  "name": "TEXT", "age": "INTEGER"
});

func list_users(req) {
  return ok(orm_all("users"));
}

get("/users", "list_users");
serve(8080);  // + Swagger UI, /openapi.json

counter.tpr

// Count lines in all .tpr files
var total = 0;
var files = list_dir(".");

for (str f in files) {
  if (endsWith(f, ".tpr")) {
      str content = read_file(f);
      var lines = split(content, "\n");
      int n = length(lines);
      print(f + ": " + toString(n));
      total = total + n;
  }
}

print("Total: " + toString(total));

stats.tpr

// Compute stats from a dataset
func mean(array data) {
  float sum = 0.0;
  for (var x in data) {
      sum = sum + toFloat(x);
  }
  return sum / toFloat(length(data));
}

var scores = [85, 92, 78, 96, 88, 73, 91];
float avg = mean(scores);
print("Average: " + toString(avg));
print("Max:     " + toString(max(scores)));
print("Min:     " + toString(min(scores)));

Benchmarks

Fast where it counts

Throughput on GET / → JSON {“hello”:“world”}, keep-alive, native load tester, one 14-vCPU box. Each runtime in its recommended single-process config.

Tulparpool · 14c

~36k req/s

Go net/http14c

~30k req/s

Node.js http1c

~8.7k req/s

FastAPIuvicorn · 1w

~3.5k req/s

And latency stays low: p50 0.32 ms (Tulpar) vs 3.3 ms (FastAPI). On CPU, fib lands at 1.37× C (Windows / MinGW) to ~1.9× C (Linux gcc -O2) — Rust/Go class either way. Full methodology →

Why Tulpar?

All-in-one vs. assembly required

What takes four packages elsewhere ships in a single binary with Tulpar.

	TulparLang	Go	Python (FastAPI)	Node.js
HTTP Server	✅ Built-in	✅ Built-in	❌ pip install	⚠️ Minimal
ORM / Database	✅ Built-in	❌ go get gorm	❌ pip install	❌ npm install
OpenAPI / Swagger	✅ Auto-generated	❌ External tool	⚠️ Plugin	❌ npm install
Deployment	Single binary	Single binary	Container needed	Container needed
Memory Model	ARC	GC (stop-the-world)	GC + refcount	GC (V8)
Throughput	~36k req/s	~30k req/s	~3.5k req/s	~8.7k req/s
C Interop (FFI)	✅ Native	✅ cgo	⚠️ ctypes / cffi	⚠️ node-ffi

Features

Everything you need is already in the box

🚀

An API on day one

import “wings”, register a route, serve(8080) — done. You get OpenAPI 3.0 + Swagger UI auto-generation, schema validation (invalid body → 422), dependency injection, structured logging, keep-alive, plus built-in /healthz and /metrics (JSON + Prometheus) for free.

⚡

C-class performance

AOT-compiled via LLVM 18 to a standalone native binary. No VM overhead in production.

🗄️

SQLite + ORM

Embedded SQLite and an Active-Record ORM — no driver to wire up.

🧬

ARC Memory

Automatic Reference Counting (ARC) for safe, predictable memory — no stop-the-world GC pauses.

🔗

C FFI

Call any C library directly. Native interop with zero wrapper overhead.

🧰

Editor tooling

Bundled LSP, tulpar fmt, and a VS Code extension.

📦

Package manager

tulpar pkg with a tulpar.toml manifest and lockfile.

🌍

UTF-8 · TR + EN

Full Turkish keyword support (fonk, eğer, döndür) and bilingual compiler diagnostics.

Write code in your language

English and Turkish — same compiler, same binary

Every keyword has a Turkish equivalent. Mix freely, or write entirely in one language. Compiler diagnostics follow your locale.

ENgreet.tprEnglish syntax

import "wings";

func greet(req) {
    var name = req.json["name"];
    if (name == "") { return bad_request("Name required"); }
    return ok("Hello, " + name + "!");
}

post("/greet", "greet");
serve(8080);

TRselamla.tprTürkçe sözdizimi

içe_aktar "wings";

fonk selamla(req) {
    değişken isim = req.json["name"];
    eğer (isim == "") { döndür bad_request("İsim gerekli"); }
    döndür ok("Merhaba, " + isim + "!");
}

post("/selamla", "selamla");
serve(8080);

Live playground

Try it right here in your browser

No install, no setup. Edit the code and hit Run — it executes in the page.

hello.tpr — recursion + the ternary operator

Run

// Classic recursion, one-line branches with cond ? a : b func fib(int n) { return n < 2 ? n : fib(n - 1) + fib(n - 2); } for (int i = 0; i < 12; i++) { print("fib(" + toString(i) + ") = " + toString(fib(i))); }

From zero to a REST API

A persistent CRUD service in one file

Model, routes and server in a single .tpr — boots with /healthz, /metrics, /openapi.json and a Swagger UI for free.

import "wings";
import "orm";

orm_open("app.db");
define_model("users", {
    "id":   "INTEGER PRIMARY KEY AUTOINCREMENT",
    "name": "TEXT NOT NULL",
    "age":  "INTEGER"
});

func list_users(req)  { return ok(orm_all("users")); }

func create_user(req) {
    int id = orm_create("users", req.json);
    return created(orm_find("users", id));
}

get("/users",  "list_users");
post("/users", "create_user");
body_schema({"name": "str", "age?": "int"});   // invalid body → 422, automatically

serve(8080);

Want the guided version? The Wings Tutorial builds three complete apps step by step — REST, token auth, and a SQLite-backed API.

Ready in one command

Install the toolchain, then compile and run your first program. macOS, Linux, and Windows.

$ curl -fsSL https://tulparlang.dev/install.sh | bash

Get Started →  ·  Installation  ·  Language Guide