The runtime forAI-native infrastructure

SPR v0.7.0 · Semantic Pipeline Runtime

The runtime for

Build, sandbox, and deploy LLM pipelines with a single \~10 MB binary. No Python. No dependencies. No vendor lock-in.

23

AI Builtins

230+

Tests

\~10 MB

Binary Size

4

Providers

9

Modules

▶ Try in Browser Read the Docs →

Try Pipe in your browser

Probier Pipe im Browser

No install. No signup. Just type Pipe code and run.

Keine Installation. Keine Anmeldung. Einfach tippen und ausführen.

pipe playground

✦ ▶ Run

Loading WASM...

Running AI in production is harder than it should be

KI in Produktion ist schwieriger als nötig

🔒

#### Security

#### Sicherheit

LLMs with file access, network, and `exec` are a liability. You need sandboxing at the language level — not afterthought middleware.

LLMs mit Dateizugriff, Netzwerk und `exec` sind ein Risiko. Du brauchst Sandboxing auf Sprachebene — kein nachträgliches Middleware-Gefrickel.

🐌

#### Performance

#### Performance

Sequential API calls turn a 1-second pipeline into a 10-second bottleneck. Parallelism shouldn't require `asyncio.gather()` boilerplate.

Sequentielle API-Calls machen aus einer 1-Sekunden-Pipeline einen 10-Sekunden-Flaschenhals. Parallelismus sollte kein `asyncio.gather()`\-Boilerplate brauchen.

🔗

#### Vendor Lock-in

#### Vendor-Lock-in

Switching from OpenAI to DeepSeek means rewriting your SDK code. Provider changes should be one line — not a refactor.

Von OpenAI zu DeepSeek wechseln heißt SDK-Code umschreiben. Provider-Wechsel sollten eine Zeile sein — kein Refactor.

Pipe fixes this at the language level. Pipe löst das auf Sprachebene.

From log files to AI agents — in a few lines

Von Logdateien bis KI-Agenten — in wenigen Zeilen

Log Analysis → Incident Report

Log-Analyse → Incident-Report

Read server logs, classify severity with AI, filter critical entries, summarize findings, translate to German, and save — 5 lines. No intermediate files. No Python script.

Server-Logs einlesen, Schweregrad per KI klassifizieren, kritische Einträge filtern, zusammenfassen, ins Deutsche übersetzen und speichern — 5 Zeilen. Keine Zwischendateien. Kein Python-Skript.

read_file "/var/log/app/errors.log" > split "\n" > classify ["critical", "warning", "info"] > filter (fn l: l == "critical") > summarize > translate "de" > save "incident_report.txt"

RAG Pipeline — Semantic Search

RAG-Pipeline — Semantische Suche

Vectorize your documents, embed the question, find the nearest matches by meaning — not keywords. Built-in `embed`, `nearest`, `cosine_sim`. No vector DB setup. No Pinecone.

Dokumente vektorisieren, Frage einbetten, ähnlichste Treffer nach Bedeutung finden — nicht nach Stichwörtern. Eingebaute `embed`, `nearest`, `cosine_sim`. Keine Vektor-DB. Kein Pinecone.

docs: read_lines "knowledge_base.txt" vectors: embed_batch docs

question: "How does the bytecode VM work?" q_vec: embed question top: nearest q_vec vectors 3

context: "" for idx in top context: context ++ (at docs idx) ++ "\n---\n"

ask ("Context:\n" ++ context ++ "\nQuestion: " ++ question) > print

AI Agents — Sandboxed & Parallel

KI-Agenten — Sandboxed & Parallel

Define a tool, register it with the LLM, and let the model call it autonomously. Sandbox profiles lock down `exec`, `write_file`, and network access — safe by default. The same code swaps between OpenAI, DeepSeek, and Ollama with one line.

Ein Tool definieren, beim LLM registrieren und das Modell autonom aufrufen lassen. Sandbox-Profile sperren `exec`, `write_file` und Netzwerkzugriff — standardmäßig sicher. Derselbe Code wechselt mit einer Zeile zwischen OpenAI, DeepSeek und Ollama.

-- Declare a sandbox: temp files only, network ok, no exec sandbox_profile "agent" {fs: "temp-only", network: true, exec: false, ai: true} set_sandbox "agent"

fn get_weather city match city | "Berlin" -> "22°C, sunny" | "London" -> "15°C, rainy" | _ -> city ++ ": no data"

ai_tool "get_weather" "Get current weather for a city" {city: "City name"} get_weather

ai_with_tools "You are a weather assistant." "What's the weather in Berlin and London?" > print

Pipe vs. Python + LangChain

Pipe vs. Python + LangChain

Same job. Less code. Built-in safety.

Gleicher Job. Weniger Code. Eingebaute Sicherheit.

| | Python + LangChain | Pipe | | ---------------------------------------------- | -------------------------------------------------------- | ---------------------------------------------------- | | RAG pipelineRAG-Pipeline | \~80 LOC\~80 Zeilen | \~10 LOC\~10 Zeilen | | Sandbox LLM accessLLM-Zugriff sandboxen | Custom middlewareCustom Middleware | One sandbox\_profile blockEin sandbox\_profile-Block | | Switch AI providerKI-Provider wechseln | Rewrite SDK callsSDK-Calls umschreiben | ai\_provider "deepseek" | | Deploy to serverAuf Server deployen | Docker + venv + pipDocker + venv + pip | scp pipe binaryscp pipe binary | | Parallel LLM callsParallele LLM-Calls | asyncio.gather() boilerplateasyncio.gather()-Boilerplate | \>> operator, ai\_batch | | Binary size (with deps)Binary-Größe (mit Deps) | \~500 MB\~500 MB | \~10 MB\~10 MB |

What you get with Pipe

Was du mit Pipe bekommst

⚡

#### Ship AI pipelines 10× faster

#### KI-Pipelines 10× schneller bauen

23 AI operations are language primitives — not library calls. `summarize`, `translate`, `classify` work without imports, SDKs, or API wrappers.

23 KI-Operationen sind Sprach-Primitives — keine Library-Calls. `summarize`, `translate`, `classify` funktionieren ohne Imports, SDKs oder API-Wrapper.

🔒

#### Lock down AI agents in one line

#### KI-Agenten in einer Zeile einsperren

Declarative sandbox profiles restrict `exec`, `write_file`, and `http_get`. Essential for `ai_with_tools` — keep LLMs on a leash.

Deklarative Sandbox-Profile beschränken `exec`, `write_file` und `http_get`. Essentiell für `ai_with_tools` — LLMs an die Leine nehmen.

🚀

#### Deploy in seconds

#### In Sekunden deployen

One statically-linked \~10 MB binary. No venv, no pip, no Docker. Linux, macOS, Windows, Raspberry Pi — or your browser via WebAssembly.

Eine statisch gelinkte \~10 MB Binary. Kein venv, kein pip, kein Docker. Linux, macOS, Windows, Raspberry Pi — oder dein Browser per WebAssembly.

⚡⚡

#### 3 LLM calls in 1.5s, not 4s

#### 3 LLM-Calls in 1,5s, nicht 4s

`>>` starts any pipeline stage in the background. Futures auto-resolve. `ai_batch` processes hundreds of texts concurrently with rate limiting.

`>>` startet jede Pipeline-Stufe im Hintergrund. Futures lösen sich automatisch auf. `ai_batch` verarbeitet hunderte Texte parallel mit Rate-Limiting.

🌐

#### No vendor lock-in

#### Kein Vendor-Lock-in

OpenAI, Anthropic, DeepSeek, Ollama. Switch providers with `ai_provider`. Same code. Same pipeline. Zero rewrites.

OpenAI, Anthropic, DeepSeek, Ollama. Provider wechseln mit `ai_provider`. Gleicher Code. Gleiche Pipeline. Keine Rewrites.

🧪

#### Tests built in

#### Tests eingebaut

Zero-setup testing: `test` blocks with `assert_eq`, `assert_error`. Run via `pipe -test`. No framework. No config. Official GitHub Action for CI.

Testen ohne Setup: `test`\-Blöcke mit `assert_eq`, `assert_error`. Ausführen per `pipe -test`. Kein Framework. Keine Config. Offizielle GitHub Action für CI.

📦

#### Module ecosystem

#### Modul-Ökosystem

9 curated modules. Pin versions with `@1.0.0`. `pipe -search` discovers, `pipe -get` installs. Import by name — no URLs.

9 kuratierte Module. Versionen pinnen mit `@1.0.0`. `pipe -search` entdeckt, `pipe -get` installiert. Import per Name — keine URLs.

🔌

#### VSCode & CI/CD ready

#### VSCode & CI/CD ready

LSP-powered IntelliSense: completion, hover docs, go-to-definition, diagnostics. GitHub Action runs Pipe in CI — no install, sandboxed by default.

LSP-powered IntelliSense: Completion, Hover-Docs, Go-to-Definition, Diagnostics. GitHub Action führt Pipe in CI aus — keine Installation, standardmäßig sandboxed.

⚙️

#### Bytecode VM — 7× faster

#### Bytecode-VM — 7× schneller

Compile to 40 opcodes, execute on a stack machine with automatic caching. Tree-walker for development, VM for production.

Kompilieren in 40 Opcodes, Ausführung auf einer Stack-Machine mit automatischem Caching. Tree-Walker für Entwicklung, VM für Produktion.

Built for production AI workloads

Gebaut für Produktions\-KI-Workloads

230+

Tests

Tests

\~15k

LoC Go

LoC Go

42

Example Programs

Beispielprogramme

4

AI Providers

KI-Provider

\~10 MB

Binary

Binary

0

Dependencies

Abhängigkeiten

23 AI Builtins \+ 91 Standard Builtins

23 KI-Builtins \+ 91 Standard-Builtins

#### 🧠 Understanding

| summarize | Text summarization | | --------- | ---------------------- | | translate | Translation | | classify | Classification | | extract | Data extraction (JSON) | | ask | Question answering | | generate | Free-text generation |

#### ⚡ Speed & Parallel

| ai\_stream | Real-time token streaming | | --------------- | ------------------------- | | ai\_batch | Auto-parallel batch | | ai\_parallel | Concurrency control | | ai\_rate\_limit | Rate limiting | | ai\_chat | Low-level chat | | ai\_chat\_json | Chat → structured JSON |

#### 🔍 Embeddings & Search

| embed | Text → vector | | ------------ | ------------------- | | embed\_batch | Batch embeddings | | cosine\_sim | Semantic similarity | | dot\_product | Dot product | | nearest | Top-K nearest |

#### 🤖 Tool Calling & Config

| ai\_tool | Register function as tool | | --------------- | ------------------------- | | ai\_with\_tools | Chat with tool access | | ai\_provider | Select AI provider | | ai\_model | Select model | | ai\_timeout | Set timeout |

#### 🔒 Sandbox Profiles

| sandbox\_profile | Define a sandbox profile | | ---------------- | ------------------------ | | set\_sandbox | Activate a profile | | with\_sandbox | Temp profile override |

#### 🧪 Testing

| test | Grouped test block | | ------------- | ------------------ | | assert | Truthy check | | assert\_eq | Equality check | | assert\_lt | Less-than check | | assert\_gt | Greater-than check | | assert\_error | Expect an error |

Get started in 30 seconds

In 30 Sekunden starten

🌐

#### Browser Playground

#### Browser-Playground

Write and run Pipe code instantly. No install. No signup. Full syntax highlighting.

Pipe-Code sofort schreiben und ausführen. Keine Installation. Kein Login. Volles Syntax-Highlighting.

Open Playground

💻

#### Local Install

#### Lokal installieren

`git clone` \+ `make build`. One binary. Set your API key. Done.

`git clone` \+ `make build`. Eine Binary. API-Key setzen. Fertig.

Install Guide

🔄

#### CI/CD Action

#### CI/CD-Action

Run Pipe in GitHub Actions. Sandboxed by default. No installation. AI-enabled on demand.

Pipe in GitHub Actions ausführen. Standardmäßig sandboxed. Keine Installation. KI bei Bedarf aktivierbar.

GitHub Action Docs

Advanced features

Fortgeschrittene Features

Self-Healing Code

Selbstheilender Code

`try_ai` catches runtime errors and uses AI to automatically fix the broken expression — type mismatches, division by zero, index errors. If the AI can't fix it, execution falls to `catch`. No other language has this.

`try_ai` fängt Laufzeitfehler und nutzt KI um den Ausdruck automatisch zu reparieren — Typ-Fehler, Division durch Null, Index-Fehler. Wenn die KI nicht fixen kann, fällt es ins `catch`. Keine andere Sprache kann das.

try_ai "42" 3 -- E002: STRING INTEGER catch e 0 -- fallback if AI fix fails

-- AI auto-fix: (to_num "42") * 3 → 126 ✓

Parallel by Design

Parallel per Design

`>>` starts any pipeline stage in the background — returning a Future that auto-resolves when needed. `ai_batch` handles hundreds of texts concurrently with built-in rate limiting. No async/await. No Promise.all.

`>>` startet jede Pipeline-Stufe im Hintergrund — und gibt einen Future zurück, der sich automatisch auflöst. `ai_batch` verarbeitet hunderte Texte parallel mit eingebautem Rate-Limiting. Kein async/await. Kein Promise.all.

-- 3 AI calls — ~1.5s instead of ~4s a: "Capital of France?" >> ask b: "Capital of Germany?" >> ask c: "Capital of Italy?" >> ask

print a ++ " | " ++ b ++ " | " ++ c

Modern Control Flow

Moderne Kontrollstrukturen

C-style `for` loops, multi-pattern `match`, and a `not` keyword keep everyday scripting painless. All compiled to bytecode with proper continue/break support.

C-Style-`for`\-Schleifen, Multi-Pattern-`match` und ein `not`\-Keyword machen alltägliches Scripting angenehm. Alles in Bytecode kompiliert mit voller continue/break-Unterstützung.

for i: 0; i < 5; i: i + 1 print i

match 6 | 2 | 4 | 6 -> print "even" | 1 | 3 | 5 -> print "odd"

if not (2 > 3) print "clearly true"

AI models learn Pipe in seconds

KI-Modelle lernen Pipe in Sekunden

The Pipe syntax is AI-friendly by design. Its heart is the pipeline: data flows top to bottom through `>`, step by step — the same way AI models reason about a task. Here's why models understand and learn Pipe so quickly.

Die Pipe-Syntax ist von Haus aus KI-freundlich. Ihr Herzstück ist die Pipeline: Daten fließen von oben nach unten durch `>`, Schritt für Schritt — genauso, wie KI-Modelle über eine Aufgabe nachdenken. Deshalb verstehen und erlernen Modelle Pipe so schnell.

Pipelines read like reasoning — step by step, top to bottom

Pipelines lesen sich wie Denken — Schritt für Schritt, von oben nach unten

An AI task is a sequence of steps: read → clean → classify → summarize → deliver. Pipe writes that sequence literally — every `>` is one transformation, top to bottom. A model doesn't have to reverse-engineer control flow or hunt for side effects; the code is a straight line from input to result, exactly the shape of a reasoning chain.

Eine KI-Aufgabe ist eine Folge von Schritten: lesen → bereinigen → klassifizieren → zusammenfassen → liefern. Pipe schreibt diese Folge wörtlich — jedes `>` ist eine Transformation, von oben nach unten. Ein Modell muss keinen Kontrollfluss rekonstruieren und keine Seiteneffekte suchen; der Code ist eine gerade Linie vom Input zum Ergebnis — exakt die Form einer Denkkette.

-- one step per line, top to bottom — like a reasoning chain read_file "tickets.txt" > split "\n" > classify ["bug", "feature", "question"] > summarize > save "report.md"

Tiny grammar — learnable in a single pass

Winzige Grammatik — in einem Durchgang lernbar

Around 20 keywords, 66 token types, 33 AST node types. No classes, no generics, no decorators, no `async` model to absorb. The whole language fits on a page — so a model memorizes it in one glance and stays inside the grammar instead of drifting out of it.

Rund 20 Keywords, 66 Token-Typen, 33 AST-Nodes. Keine Klassen, keine Generics, keine Dekoratoren, kein `async`\-Modell zum Aufnehmen. Die ganze Sprache passt auf eine Seite — ein Modell erfasst sie auf einen Blick und bleibt innerhalb der Grammatik, statt herauszudriften.

-- ~20 keywords · no classes · no types · no braces fn classify_ticket t match t | "refund" -> "billing" | "crash" -> "bug" | _ -> "other"

-- implicit calls: no parentheses, no commas print (classify_ticket "crash")

Familiar shapes — nothing a model has to unlearn

Vertraute Formen — nichts, das ein Modell verlernt

Pipe uses the structures LLMs are already best at: indentation-based blocks like Python, and implicit space-separated calls instead of parentheses and commas. No braces to balance, no semicolons, no delimiter bookkeeping — the most common source of codegen bugs is simply not there.

Pipe nutzt die Strukturen, in denen LLMs ohnehin am besten sind: einrückungsbasierte Blöcke wie in Python und implizite, leerzeichengetrennte Aufrufe statt Klammern und Kommas. Keine geschweiften Klammern, keine Semikolons, keine Klammern-Buchhaltung — die häufigste Codegen-Fehlerquelle existiert schlicht nicht.

-- Python: (), [], :, , — four kinds of bookkeeping if len(items) > 3 and items[0] != nil: ...

-- Pipe: indentation blocks, space-separated calls if (len items) > 3 && (at items 0) != nil print "many items"

Self-describing verbs — the syntax reads like instructions

Selbstbeschreibende Verben — die Syntax liest sich wie Anweisungen

`summarize`, `translate`, `classify`, `ask`, `embed`, `nearest` — the verb is the operation. No client objects, no `messages` dicts, no model IDs, no API-key plumbing to remember. Code sits one step from natural language, so a model maps your task to the syntax without ceremony.

`summarize`, `translate`, `classify`, `ask`, `embed`, `nearest` — das Verb ist die Operation. Keine Client-Objekte, keine `messages`\-Dicts, keine Modell-IDs, keine API-Key-Klempnerei, die man sich merken müsste. Code liegt einen Schritt von natürlicher Sprache entfernt, sodass ein Modell deine Aufgabe ohne Zeremonie in Syntax übersetzt.

-- the verbs ARE the operation ticket: read_file "ticket.txt" summary: summarize ticket reply: translate summary "de"

print reply

🧠

#### Chain-of-thought syntax

#### Chain-of-Thought-Syntax

Every `>` is one reasoning step. The pipeline is the plan — models read intent directly from the shape.

Jedes `>` ist ein Denkschritt. Die Pipeline ist der Plan — Modelle lesen die Absicht direkt aus der Form.

📖

#### Linear & stateless

#### Linear & zustandslos

No control-flow maze, no mutable state to track. The whole program stays in context.

Kein Kontrollfluss-Labyrinth, kein veränderlicher Zustand zu verfolgen. Das ganze Programm bleibt im Kontext.

🚫

#### Nothing to unlearn

#### Nichts zu verlernen

Indentation like Python, implicit calls instead of brackets — structures models already handle best.

Einrückung wie in Python, implizite Aufrufe statt Klammern — Strukturen, die Modelle ohnehin am besten beherrschen.

🧩

#### Small grammar

#### Kleine Grammatik

The whole language fits on a page — learnable in one glance, easy to stay inside.

Die ganze Sprache passt auf eine Seite — auf einen Blick lernbar, leicht darin zu bleiben.

🗣️

#### Verbs, not plumbing

#### Verben, keine Klempnerei

Self-describing AI verbs read like instructions — no SDKs or API schemas to memorize.

Selbstbeschreibende KI-Verben lesen sich wie Anweisungen — keine SDKs oder API-Schemas zum Merken.

📉

#### Short output

#### Kurzer Output

5 lines replace \~80. Fewer tokens to generate, less room for the model to drift.

5 Zeilen statt \~80. Weniger Tokens zu generieren, weniger Raum für Drift.