The first language with built-in MCP — server and client. 238 builtins, single ~8 MB binary. Zero dependencies. Officially listed in the official MCP Registry (v1.0.0, active). One-click install from GitHub MCP Registry for Copilot & VS Code.
Pipe v1.0.0 is the production-ready release, consolidating the entire v0.9.x series:
- Guard clauses —
| pattern if cond -> bodyin match expressions - Concurrency primitives — channels (
send/recv/try_recv), mutex (lock/unlock), counting semaphore (acquire/release) - Bytecode-VM improvements — constant folding, alias import namespaces, bytecode cache
- MQTT 5.0 module — pure Pipe MQTT client with input validation, CONNACK properties, DISCONNECT handling
- docs-pipe — RAG module for documentation-native search with heading-aware chunking
- Test framework — setup/teardown hooks,
assert_near/assert_contains, VM test blocks - Hardened sandbox — audit rounds 1-6, deterministic env masking, central egress gate
- 238 builtins — 36 AI + 13 MCP + 189 standard, up from 226 in v0.9.3
- 23 modules — MQTT, SQLite, pipe-http, pipe-web, pipe-orm, pipe-cli, and more
curl -fsSL https://pipe-lang.com/install.sh | bash # Linux & macOSWindows (PowerShell): irm https://pipe-lang.com/install.ps1 | iex
The installer downloads the latest release, verifies its SHA256 checksum and installs pipe into ~/.local/bin (or /usr/local/bin when run as root). Pin a version with PIPE_VERSION=v1.0.0. See the full install docs.
Pipe is DSGVO-konform / GDPR-compliant by design:
- Zero telemetry & analytics — the binary never phones home, nothing leaves your machine
- Self-hosted single binary — runs entirely on your infrastructure
- No cloud — no vendor server processes your data
- Open source (MIT) — fully auditable
- Local AI — with Ollama, not a single byte leaves your network; cloud providers are used only if you configure one
Running AI in production is harder than it should be:
- Security — LLMs with file access, network, and
execare a liability. You need fine-grained sandboxing at the language level, not afterthought middleware. - Performance — Sequential API calls turn a 1-second pipeline into a 10-second bottleneck. Parallelism shouldn't require
asyncio.gather()boilerplate. - Vendor Lock-in — Switching from OpenAI to DeepSeek means rewriting your Python SDK code. Provider changes should be one line.
- Tool Integration — Connecting LLMs to external tools (GitHub, databases, filesystems) is a maze of SDKs and API wrappers. MCP should be a language primitive, not a library.
Pipe fixes this at the language level.
Pipe is a Semantic Pipeline Runtime (SPR) — a pipeline-native language where summarize, translate, and classify sit on the same syntax level as +, sort, and len. Data flows top to bottom through composable transformations. One binary. Zero dependencies.
Python + LangChain (~80 lines):
import openai
client = openai.OpenAI()
def summarize(text):
r = client.chat.completions.create(model="gpt-4o", messages=[{"role":"user","content":text}])
return r.choices[0].message.content
def translate(text, lang):
r = client.chat.completions.create(model="gpt-4o",
messages=[{"role":"system","content":f"Translate to {lang}"},{"role":"user","content":text}])
return r.choices[0].message.content
text = open("news.txt").read()
print(translate(summarize(text), "de"))Pipe (5 lines):
read_file "news.txt"
> summarize -- LLM call
> translate "de" -- LLM call
> print
Pipe has built-in MCP — both as a server and client. No SDKs, no npm packages, no Python. Pure Go stdlib.
fn get_weather city
match city
| "Berlin" -> "22°C, sunny"
| "London" -> "15°C, rainy"
| _ -> city ++ ": no data"
ai_tool "get_weather" "Get weather for a city" {city: "City name"} get_weather
mcp_server "Weather Agent" "1.0.0"
mcp_serve_stdio
Configure in Claude Desktop (claude_desktop_config.json):
{ "mcpServers": { "pipe": { "command": "/tmp/pipe", "args": ["agent.pipe"] } } }ai_provider "deepseek"
ai_set_key "deepseek" (env "DEEPSEEK_API_KEY")
-- Connect to GitHub + Filesystem MCP servers
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-github" {GITHUB_TOKEN: (env "GITHUB_TOKEN")}
mcp_use_stdio "npx" "-y" "@modelcontextprotocol/server-filesystem" "/tmp"
-- AI discovers and uses all tools automatically
result: ai_with_tools "You are a DevOps assistant." "Search pipe's open issues and list files in /tmp." 10
print result
Any stdio MCP server works immediately: Filesystem, GitHub, Git, Postgres, SQLite, Slack, Brave Search, Memory, Sequential Thinking — anything on npm/uvx.
is_critical: fn line
contains line "critical"
read_file "/var/log/app/errors.log"
> split "\n"
> filter is_critical
> summarize
> translate "de"
> save "incident_report.txt"
ai_provider "deepseek"
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
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: "Name of the city"} get_weather
ai_with_tools "You are a weather assistant." "What's the weather in Berlin and London?"
> print
ai_provider "deepseek"
a: "Explain monads" >> ask
b: "What is CP/M?" >> ask
c: "Explain RFC 791" >> ask
print a ++ b ++ c -- Future auto-resolution
import "discord.pipe" as d
ai_provider "deepseek"
-- AI code review per commit, sent as Discord embed
review: ai_chat "Review this code change" diff 800
d.d_webhook_embed (env "DISCORD_WEBHOOK") {
title: "CI: Push to master",
color: 3447003,
fields: [
{name: "Changed Files", value: stat},
{name: "AI Review", value: review}
]
}
| Python + LangChain | Pipe | |
|---|---|---|
| RAG pipeline | ~80 LOC | ~8 LOC |
| Sandbox LLM access | Custom middleware | One sandbox_profile block |
| Switch AI provider | Rewrite SDK calls | ai_provider "deepseek" |
| Deploy to server | Docker + venv + pip | scp pipe binary |
| Parallel LLM calls | asyncio.gather() boilerplate |
>> operator, ai_batch |
| MCP Server + Client | Library-dependent | 13 builtins, zero deps, 100+ servers |
| Binary size | ~500 MB (with deps) | ~8 MB |
- MCP-native — 13 builtins for MCP Server + Client. Pure Go stdlib. Connect to any stdio MCP server
- Ship AI pipelines 10x faster — 36 AI + 13 MCP builtins: no imports, no SDKs, no API wrappers
- Lock down AI agents in one line — Declarative sandbox profiles: restrict
exec,write_file,http_getwith a single block - Deploy in seconds — One statically-linked ~8 MB binary. No venv, no pip, no Docker. Linux, macOS, Windows, Raspberry Pi, or your browser via WebAssembly
- 3 LLM calls in 1.5s, not 4s —
>>starts any pipeline stage in the background. Futures auto-resolve.ai_batchhandles hundreds of texts concurrently with built-in rate limiting - No vendor lock-in — OpenAI, Anthropic (Claude), DeepSeek, Ollama. Switch with one line. Same code works everywhere
- Concurrency primitives — channels (
send/recv), mutex (lock/unlock), counting semaphore (acquire/release) - Pipeline-native syntax —
>sequential,>>parallel. Data flows top to bottom — readable, composable, debuggable - Social platforms built in — Discord webhooks and Telegram bots as Pipe modules. AI code reviews, notifications, chat — zero API costs for sending
- Bytecode VM — Compile to bytecode, run on a stack VM with automatic caching. Measured 0.6x-55x vs tree-walker depending on workload (recursion-heavy code up to ~55x)
- Module ecosystem — 23 curated modules, registry with version pinning (
@1.0.0).pipe -getinstalls, import by name - Built-in testing —
testblocks withassert_eq,assert_error. Run withpipe -test. Zero setup - GitHub Action — Run Pipe directly in CI/CD. No installation needed
- VSCode Extension — Syntax highlighting, IntelliSense, LSP-powered diagnostics and completions
- Self-extracting binary — Ship your pipeline as a standalone executable (
pipe -build)
git clone https://github.com/MachuraHarry/pipe && cd pipe && make build
export DEEPSEEK_API_KEY="sk-..."
./bin/pipe -vm -q -c 'ai_provider "deepseek"; ask "What makes Pipe different?" > print'No install needed — Pipe runs fully in your browser via WebAssembly:
-- Paste this into the playground and hit Run
levels: ["error","warn","info"]
read_file "server.log"
> classify levels
> summarize
> print
Run Pipe directly in CI/CD — no installation needed:
- uses: MachuraHarry/pipe/.github/actions/pipe-action@master
with:
script: |
print "Hello from CI/CD!"
log: exec "git log --oneline -20"
print (get log "output")Syntax highlighting and full IntelliSense for .pipe files, powered by a Language Server Protocol client (vscode/) and the pipe-lsp server (cmd/pipe-lsp):
- Completion, hover docs, signature help, go-to-definition, references, rename
- Diagnostics (parse errors, undefined/unused variables) and semantic highlighting
- Format document, auto-completion of brackets, auto-indent and code folding
make vsix # builds the server and packages vscode/pipe-syntax-1.0.0.vsixOr run the extension in development with F5 from the vscode/ folder. See VSCode Extension Documentation.
Pipe has a curated module library — 23 reusable modules with version pinning:
| Infrastructure | Data & CLI | AI & Agents | DevTools | Social |
|---|---|---|---|---|
pipe-http |
sqlite |
rag-pipe |
pipe-test |
telegram-bot |
pipe-cli |
jpipe |
log-analyzer |
pipe-validate |
mqtt |
pipe-orm |
pipe-tpl |
sentiment |
||
pipe-web |
pipe-date |
code-review |
||
translate-batch |
||||
changelog-gen |
||||
email-classifier |
||||
incident-report |
||||
parallel-runner |
||||
date-formatter |
||||
docs-pipe |
pipe -search # Browse modules
pipe -search sql # Filter by keyword
pipe -get sqlite # Install latest
pipe -get sqlite@0.8.0 # Install specific versionimport "sqlite" -- database engine
import "pipe-http" -- HTTP client
import "mqtt" -- MQTT 5.0 client
import "discord.pipe" as d -- Discord webhooks + bot
idx: index_create h "knowledge"
index_add idx "Pipe is an AI-native language."
index_search idx "language" 3 > each print
→ Ecosystem Documentation | → Contribute a Module
| Mode | Command | Speed |
|---|---|---|
| Tree-Walker | ./bin/pipe script.pipe |
Baseline |
| Bytecode VM | ./bin/pipe -vm -q script.pipe |
0.6x-55x (recursion-heavy up to ~55x) |
summarize, translate, classify, extract, ask, generate, generate_json
ai_stream, ai_batch, ai_parallel, ai_rate_limit, ai_chat, ai_chat_json
web_search, wiki_search, embed, embed_batch, cosine_sim, dot_product, nearest
agent, agent_ask, agent_clear, ai_tool, ai_with_tools
ai_provider, ai_model, ai_host, ai_set_key, ai_timeout, ai_cache, ai_cost, ai_tokens, ai_cache_hits, ai_cache_misses
mcp_server, mcp_serve_stdio, mcp_serve_sse, mcp_tools, mcp_resource, mcp_resource_template, mcp_prompt, mcp_resources, mcp_read_resource, mcp_prompts, mcp_prompt_get, mcp_use_stdio, mcp_use_sse
try_ai, try_ai_log
ai_provider "deepseek"
result: try_ai
"42" * 3 -- E002 Type Error -> AI wraps with to_num -> 126
catch e
0 -- only reached if AI fix fails
print result -- 126
a: "Frage A"
>> ask
b: "Frage B"
>> ask
c: "Frage C"
>> ask
print a ++ b ++ c -- Future auto-resolution
fn classify severity
match severity
| s if s > 9 -> "critical"
| s if s > 5 -> "warning"
| _ -> "info"
ch: chan 3
go { send ch "hello" }
go { send ch "world" }
print (recv ch) ++ " " ++ (recv ch)
sandbox_profile "safe" {fs: "read-only", network: false, exec: false, ai: true}
sandbox_profile "agent" {fs: "temp-only", network: true, exec: false, ai: true}
set_sandbox "safe"
read_file "/etc/config" -- reading allowed
write_file "/etc/config" -- E_SANDBOX blocked
Source (.pipe) -> Lexer -> Parser -> AST -> [ Tree-Walker | Compiler + VM ]
|
Builtins (238 total: 36 AI + 13 MCP + 189 standard)
|
MCP Server <-> MCP Clients (stdio + HTTP)
- 67 token types, 36 AST node types, 43 opcodes
- ~37,000 LoC Go, 643 tests, 87 example programs
- Zero dependencies — pure Go stdlib
→ Full documentation (English) → Vollständige Dokumentation (Deutsch)
pipe/
├── cmd/
│ ├── pipe/main.go # Entry point
│ └── pipe-lsp/ # Language Server Protocol server (IntelliSense)
├── pkg/
│ ├── ai/ # AI provider integrations
│ ├── analysis/ # IntelliSense library (builtins, diagnostics, completion...)
│ ├── ast/ # AST node definitions
│ ├── build/ # Self-extracting binary builder
│ ├── cache/ # Bytecode cache
│ ├── compiler/ # Compiler to bytecode
│ ├── eval/ # Tree-walk interpreter
│ ├── formatter/ # Code formatter
│ ├── gen/ # Code generation helpers
│ ├── lexer/ # Lexer and tokens
│ ├── mcp/ # MCP server + client (zero-dependency)
│ ├── object/ # Runtime objects
│ ├── parser/ # Parser
│ ├── stdlib/ # Standard library helpers
│ └── vm/ # Bytecode VM
├── examples/ # 87 example programs
├── test/integration/ # Integration tests
├── vscode/ # VSCode extension (syntax highlighting + LSP client)
├── docs/ # Documentation (DE + EN)
├── website/ # Project website
├── modules/ # Language modules (mqtt, discord, x, etc.)
├── Makefile
├── go.mod
└── LICENSE
See CONTRIBUTING.md.
MIT — see LICENSE.