A data format that is also a programming language, compiled straight to WebAssembly GC.
contact{ name: James age: 33 }
assert contact.age + 1 == 34
The same notation holds your config, your markup and your program. Warp compiles it to WebAssembly GC structs (no linear-memory runtime, no JS glue), and the warp compiler is itself a WebAssembly module written in warp itself!
▶ Try it in your browser: nothing to install. The compiler runs locally in a Web Worker.
Even when 99% of code is written by AI, we can aim for the perfect programming language: ideal for humans and AI alike, type safe but not verbose, universal and fast (compiled ahead of time to WebAssembly), highly structured and expressive. Agents benefit from clean abstractions too.
- Data is code. Like Lisp, but with blocks, lists, key-value pairs and tags instead of s-expressions. JSON-like, but no quotes around keys or symbols. Reads and writes JSON, XML and YAML.
- Wasm GC first. A
class Person{name:String age:i64}becomes a real(struct …)type, and the module carries full name sections, so any Wasm GC host sees typed objects (see below). - No silent footguns. When code could mean two things, the compiler doesn't guess quietly. It warns with the
reading it took and the explicit form, or it refuses when a wrong guess would corrupt results
(Footguns):
for i in 1 upto 4 { x += i } warning: does `upto 4` include 4? (`..<` or `..` exclude it, `to` or `...` include it) (taking exclusive); fix: ..< - Little ceremony. Implicit
it, inferred parameter and return types, Unicode operators, and English words for operators where they read better:square := it² square(3) + square(4) // 25 fib := if it < 2 then it else fib(it - 1) + fib(it - 2) fib(20) // 6765 - Markup is just data.
html{ body{ h1: "Welcome" p: "made of data" } }
Nothing to install: warp.pannous.com runs the compiler in your browser.
Homebrew (macOS, Linux):
brew install pannous/tap/warpLinux:
sudo apt install ./warp-lang_*_amd64.deb or sudo dnf install ./warp-lang-*.x86_64.rpm.
Prebuilt binaries (macOS arm64 and x86_64, Linux x86_64 and arm64): download the archive for your platform from the
latest release and put warp on your PATH.
From source (warp builds itself, so it needs an installed warp first):
git clone https://github.com/pannous/warp && cd warp
warp rebuild # warp.wasm, the compiler written in Warp (core/), then the native warp commandwarp # interactive console "repl"
warp help # all commands
warp sample.warp # run a file, server, webapp or gui
warp build sample.warp # the standalone executable (aot native and .wasm)
warp test # the tests under test/samples/ contains classics (game of life, Dijkstra, Levenshtein, a JSON parser, a neural net) in both a
Python-like style and an idiomatic Warp style, one folder per chapter of the guide (samples/graphics, samples/sound …).
use loads a local module, or else a package of the registry
warp-packages by name, fetched once into packages/:
use colors
to_hex(mix(from_hex("#ff0000"), from_hex("#0000ff"), 0.5)) # "#800080"
class Person{ name: text age: int }
alice = Person{ name: "Alice" age: 30 }
alice.age + 1 // 31
A class is a real GC struct, not a map in linear memory. The compiler emits (warp compile, simplified):
(type $Text (array (mut i8)))
(type $Person (struct (field $name (ref $Text)) (field $age i64)))
(func $main (result (ref $Person))
i32.const 0 i32.const 5 array.new_data $Text 0 ;; "Alice" from the data segment
i64.const 30
struct.new $Person)
(data "Alice")Texts are GC byte arrays; linear memory is used only to hand bytes to the host or C.
Untyped data travels as one universal GC type, $Node {kind: i64, data: anyref, value: (ref null $Node)}. It mirrors
the Node enum (Text, Symbol, Number, Char, Key, List, Type, Meta, Data, Error) in
core/node.warp.
Proven to be (almost) production ready by being able to compile the whole language written in warp itself! Experimental and moving fast. Tests 100% samples passing, general progress viewable in this dashboard
The language spec lives in the
wiki, and parts of it are not implemented yet. Warp began as a Rust rewrite of
Wasp (C++), which followed the Python experiments
Angle and english-script;
its compiler is now written in Warp itself (core), and so is the native warp command, which runs programs through wasmtime's C API (core/native). The old Rust compiler is preserved on the branch rust-bootstrap.
The compiler has three layers:
- core: just enough for warp to compile itself
- extensions: every other language feature
- libraries: modules programs import
Try it in your browser: Feedback and issue reports are welcome.
The compiler is licensed under the GNU AGPL v3 or later; the runtime crates/warp-runtime, which goes into every program built with warp, under the MIT license, so your programs are yours. Commercial licenses of the compiler: info@pannous.com. Contributing: CONTRIBUTING.md.