Build, sandbox, and deploy LLM pipelines with a single ~10 MB binary. No Python. No dependencies. No vendor lock-in.
No install. No signup. Just type Pipe code and run.
Keine Installation. Keine Anmeldung. Einfach tippen und ausführen.
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.
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.
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.
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"
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
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
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 |
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.
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.
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.
>>
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.
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.
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.
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.
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.
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.
| summarize | Text summarization | | translate | Translation | | classify | Classification | | extract | Data extraction (JSON) | | ask | Question answering | | generate | Free-text generation |
| 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 |
| embed | Text → vector | | embed_batch | Batch embeddings | | cosine_sim | Semantic similarity | | dot_product | Dot product | | nearest | Top-K nearest |
| 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_profile | Define a sandbox profile | | set_sandbox | Activate a profile | | with_sandbox | Temp profile override |
| 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 |
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.
git clone
make build
. One binary. Set your API key. Done.
git clone
make build
. Eine Binary. API-Key setzen. Fertig.
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.
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 ✓
>>
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
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"
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.
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"
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")
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"
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
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.
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.
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.
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.
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.
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.