Pipe – A runtime where AI operations are language primitives
Pipe (SPR v0.7.0) is a ~10 MB semantic pipeline runtime that treats AI operations like summarize, translate, and classify as first-class language primitives. It offers built-in sandboxing for LLM agents, parallel execution without async boilerplate, one-line provider switching, an embedded bytecode VM, and zero-dependency deployment for AI-native infrastructure.
Pipe — The runtime for AI-native infrastructure
SPR v0.7.0 · Semantic Pipeline Runtime
The runtime for AI-native infrastructure
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
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 + LangChainPipe
RAG pipelineRAG-Pipeline~80 LOC~80 Zeilen~10 LOC~10 Zeilen
Sandbox LLM accessLLM-Zugriff sandboxenCustom middlewareCustom MiddlewareOne sandbox_profile blockEin sandbox_profile-Block
Switch AI providerKI-Provider wechselnRewrite SDK callsSDK-Calls umschreibenai_provider "deepseek"
Deploy to serverAuf Server deployenDocker + venv + pipDocker + venv + pipscp pipe binaryscp pipe binary
Parallel LLM callsParallele LLM-Callsasyncio.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
summarizeText summarization
translateTranslation
classifyClassification
extractData extraction (JSON)
askQuestion answering
generateFree-text generation
⚡ Speed & Parallel
ai_streamReal-time token streaming
ai_batchAuto-parallel batch
ai_parallelConcurrency control
ai_rate_limitRate limiting
ai_chatLow-level chat
ai_chat_jsonChat → structured JSON
🔍 Embeddings & Search
embedText → vector
embed_batchBatch embeddings
cosine_simSemantic similarity
dot_productDot product
nearestTop-K nearest
🤖 Tool Calling & Config
ai_toolRegister function as tool
ai_with_toolsChat with tool access
ai_providerSelect AI provider
ai_modelSelect model
ai_timeoutSet timeout
🔒 Sandbox Profiles
sandbox_profileDefine a sandbox profile
set_sandboxActivate a profile
with_sandboxTemp profile override
🧪 Testing
testGrouped test block
assertTruthy check
assert_eqEquality check
assert_ltLess-than check
assert_gtGreater-than check
assert_errorExpect 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 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:
[truncated for AI cost control]