June 2025 · 8 min read

Introducing Lateralus

We built a programming language where data flows left to right, errors are handled without exceptions, and the compiler ships with zero dependencies. Here's why, and how you can try it right now.

Try Lateralus in your browser

No install needed. Write code, hit Run, see results instantly.

▶ Open Playground GitHub

Why another language?

Every modern language has functions that compose. But in practice, composing them reads inside-out:

// What you write in most languages
sort(filter(map(data, transform), predicate), comparator)

You read sort first, but it runs last. Your eyes jump right-to-left, inside-to-outside, hunting for the data source. This gets worse with every nesting level.

Lateralus inverts this. The pipeline operator |> makes data flow visible and linear:

// What you write in Lateralus
data
    |> map(transform)
    |> filter(predicate)
    |> sort(comparator)

Read top-to-bottom, left-to-right. The data source is obvious. Every transformation step is on its own line. You can comment out a single step without rewriting the expression. This isn't just syntax sugar — it changes how you think about data processing.

What does Lateralus look like?

Data pipelines

let report = transactions
    |> filter(|t| t.amount > 20.0)
    |> group_by(|t| t.category)
    |> map_entries(|cat, txns| {
        let total = txns |> map(|t| t.amount) |> sum()
        (cat, total)
    })
    |> sort_by(|e| e.1, descending)

Pattern matching with guards

fn describe(shape: Shape) -> String {
    match shape {
        Circle(r) if r > 100.0 => "Large circle",
        Circle(r)                => "Circle (r={r})",
        Rect(w, h) if w == h      => "Square ({w}x{h})",
        Rect(w, h)                => "Rectangle ({w}x{h})",
    }
}

Async concurrency

async fn fetch_all(urls: [String]) -> [Response] {
    urls
        |> map(|url| spawn { http::get(url) |> await })
        |> await_all()
}

Error handling (no exceptions)

try {
    let config = parse_config("app.conf")?
    println("Loaded: {config.host}:{config.port}")
} recover err {
    println("Failed: {err}")
} ensure {
    cleanup()
}

What's in the box

Pipeline Operator

First-class |> chains. Data flows left to right, always.

🔀

Pattern Matching

Exhaustive match on enums, structs, tuples, and literals — with guards.

⚡

Async / Await

Lightweight tasks with spawn, await, and await_all.

🛡️

try / recover / ensure

Result-based errors — no exceptions, no stack unwinding.

📦

Zero Dependencies

pip install lateralus-lang and you're running. Nothing else needed.

🧩

VS Code Extension

Syntax highlighting, snippets, bracket matching — on the marketplace now.

How to get started

Option 1: Try in your browser (fastest)

Open the Lateralus Playground. Pick an example, hit Run, edit the code. No signup, no install.

Option 2: Install locally

# Install via pip
pip install lateralus-lang

# Create a file
echo 'import std::io

fn main() {
    "hello" |> println()
}' > hello.ltl

# Run it
lateralus run hello.ltl

Option 3: VS Code Extension

Search "Lateralus" in the VS Code marketplace, or install directly:

code --install-extension lateralus.lateralus-lang

The ecosystem

Lateralus isn't just a language — it's a full ecosystem:

lateralus-lang — Language spec, grammar, and samples
lateralus-compiler — Compiler, VM, and standard library
lateralus-tutorials — Step-by-step learning path
lateralus-grammar — VS Code extension (also on marketplace)
lateralus-os — An OS kernel written in Lateralus
lateralus-web — HTTP framework with pipeline routing
22+ repositories covering crypto, ML, game engines, security tools, and more

We need testers

Lateralus is young and we want feedback from real developers. Here's how you can help:

Try the playground — does the syntax click? What feels weird?
File issues — bug reports and feature requests are invaluable
Join the discussion — GitHub Discussions is open for questions, ideas, and showcase
Write something — port a script, solve an Advent of Code problem, build a tiny project
Star the repo — visibility helps us attract more contributors

Ready to try it?

Playground. Zero install. 30 seconds to your first pipeline.

▶ Open Playground Star on GitHub

Getting started

Installing Lateralus takes 30 seconds on any platform:

# Linux / macOS
curl -sSf https://lateralus.dev/install.sh | sh

# Windows
iwr -useb https://lateralus.dev/install.ps1 | iex

# Verify
lateralus --version
# lateralus 0.5.0 (c99 backend, release)

The installer puts a single binary in ~/.lateralus/bin and adds it to your PATH. No runtime dependencies, no virtual environments, no Docker containers. Uninstall by deleting the directory.

Your first pipeline

// hello.ltl — your first Lateralus program
let message = "Hello from Lateralus!"
    |> to_upper()
    |> replace("LATERALUS", "the pipeline language")
    |> println()

// Compile and run:
// $ lateralus run hello.ltl
// HELLO FROM THE PIPELINE LANGUAGE!

If you can read the code, you already understand Lateralus. Data enters from the left, flows right through transformations, and exits. That's the entire programming model.