A simple, incredibly fast Javascript runtime for the AI era.
Sofuu is a server-side JavaScript/TypeScript runtime compiled to a single dependency-free binary — a Rust shell around a hand-tuned C engine (QuickJS + libuv). LLM streaming, agents, MCP, SIMD vector math, encrypted memory, and an HTTP server are built in at the native layer: no npm packages, no framework install, no node_modules tree. Ship on macOS, Linux, or Windows.
# Installs sofuu globally onto your PATH (macOS · Linux · Windows)$ curl -fsSL https://sofuu.xyz/install | sh# Then run anything from any directory$ sofuu chat$ sofuu run app.ts# or via npm — same binary, checksum-verified$ npx sofuu
One command puts sofuu on your PATH — then run it from any terminal, in any project.
Why developers love Sofuu
The AI stack usually means a runtime, three SDKs, a vector library, an MCP client, and a web framework — all installed separately. Sofuu ships the pieces you actually need as one native binary.
AI APIs built in
sofuu.ai.stream/complete/embed talk to local (Ollama) or cloud providers over three wire formats, with SSE parsed off the JS loop. Bring your own key — there is no default model and no lock-in.
Agents & MCP
Define named agents with tools, budgets, memory, and sub-agent delegation; connect MCP client and server over stdio. Web search is keyless by default. The same loop powers sofuu chat.
Local & encrypted
Sessions, brain memory, and KV live in post-quantum encrypted QTSQ containers on your disk. Zero unprompted telemetry. Your context never has to leave the machine except the model calls you configure.
Server & tools included
Native HTTP server and streaming fetch, file I/O, child processes, TypeScript that runs with no build step, an ESM bundler, and a package installer — no Express, no tsconfig required.
~3 ms startup, ~3 MB binary
QuickJS is a pure interpreter (no JIT): boot in milliseconds, fit in a single static executable, and run the same binary on a laptop, a server, or an edge box. The installer verifies every binary against published SHA-256 sums before it lands on your PATH.
Model-agnostic by design
Endpoints are formats, not companies: OpenAI-style, Anthropic-style, or any local server. Per-model capability limits, reasoning effort, and RLM long-context routing come from a registry — not hardcoded constants.
What Sofuu is
A server-side JavaScript runtime — the kind of thing you use for an AI backend, API server, agent host, or edge automation script. No DOM, no browser APIs, no renderer. You build the frontend separately; Sofuu runs the server side with the AI layer already in the binary.
Interactive agent CLI
sofuu / sofuu chat opens a Claude-Code-style terminal agent: streaming answers, a built-in tool belt (read, write, edit, grep, glob, list_dir, bash), slash commands for provider/model/effort/cost/memory, and encrypted session resume.
Script runtime & toolchain
Run JS or TS directly (sofuu run), evaluate inline (sofuu eval), bundle to one file, and install packages without a deep node_modules tree. One binary is the whole toolchain.
Native AI module
Stream tokens as an async iterator, one-shot completions, offline 768-dim embeddings, and SIMD cosine/dot/L2 on NEON or AVX2 — all without installing an AI SDK.
Agents & sub-agents
Headless-first agent definitions with tools, memory scopes, token/wall budgets, parallel fan-out, and map-reduce over huge contexts. Delegation is a tool call the model makes; depth limits make runaway recursion impossible.
MCP client & server
Connect to any MCP tool server from scripts or chat, or expose your own tools over stdio for Claude and other MCP clients — both directions ship in the same binary.
Memory & web for agents
Persistent vector recall with decay/consolidation, encrypted KV stores, keyless web search, and page reading — the same primitives the chat agent uses when it needs to remember or look something up.
How it works under the hood
Sofuu isn't a wrapper around a browser engine — it's a purpose-built runtime: embedded QuickJS, native worker threads, and real OS sockets, sized for what AI developers actually run today.
01. Hardware SIMD Math
Hand-written SIMD kernels run vector math directly on your CPU's vector units. Cosine similarity and array math happen almost instantly, without slowing down your app.
02. Background LLM Polling
Long network requests from AI models shouldn't crash your server. Sofuu handles heavy data streams entirely in the background, keeping your main app incredibly snappy.
03. Native Web Server
By binding an asynchronous HTTP multiplexer directly over raw OS sockets, you get a clean, functional web server capable of handling massive local burst traffic beautifully.
04. Edge & Embedded Ready
With zero bulk Node modules to manage and lightning-fast boot times, Sofuu is the perfect lightweight logic layer for headless infrastructure and edge hardware.
What is Sofuu, exactly?
Sofuu is a server-side JavaScript and TypeScript runtime — the kind of thing you use to run an AI backend, an API server, or an edge automation script. There is no browser API, no DOM, and no renderer: you build your frontend separately (React, Next.js, plain HTML — whatever you like) and Sofuu runs the server side.
What makes it different from Node.js, Deno, or Bun is that the pieces you normally install separately — LLM streaming, vector math, MCP client/server, HTTP, agents, and local encrypted memory — are compiled in at the C level. No npm packages needed for any of it.
The shell, CLI, module loader, and security-sensitive parsing are Rust; the engine layer is QuickJS (ES2023) on a libuv event loop, reached through a thin FFI. The result is a single static binary, ~3 ms startup, and a sofuu command you can run from any directory after a one-line install.
| Capability | Node / Deno / Bun | Sofuu |
|---|---|---|
| LLM streaming & completions | npm install + SDK | Built in (sofuu.ai.stream) |
| MCP client + server | npm install | Built in (sofuu.mcp) |
| SIMD vector math | npm install (JS/wasm) | Built in (NEON / AVX2) |
| Agents & sub-agents | framework + packages | Built in (sofuu.agent) |
| Encrypted local memory | your database / cloud | Built in (QTSQ, post-quantum) |
| Web search for agents | API keys + packages | Built in (sofuu.web, keyless default) |
| Install footprint | ~60–100 MB + node_modules | One ~3 MB binary |
Install Sofuu
One command installs Sofuu on macOS, Linux, or Windows — it detects your platform, verifies the checksum, and drops sofuu on your PATH so you can run it from any terminal. Every build ships with QTSQ post-quantum encrypted persistence.
# Installs sofuu globally onto your PATH (macOS · Linux · Windows)$ curl -fsSL https://sofuu.xyz/install | sh# Then run anything from any directory$ sofuu chat$ sofuu run app.ts# or via npm — same binary, checksum-verified$ npx sofuu
Local by default, lean by design.
Where Sofuu sits compared to the usual ways of running JS and talking to models — not a microbenchmark, just the honest architecture differences.
| Approach | Ships as | Setup | Your data |
|---|---|---|---|
| Sofuu (local binary) | One static executable, ~4 MB | Download & run | Stays on your machine |
| Node.js + frameworks | Runtime + node_modules tree | Install & configure | Depends on your stack |
| Cloud AI APIs | Someone else's servers | Keys & SDKs | Leaves the device |
Note: We deliberately skip published latency claims — real-world speed depends on your hardware and model. Download the binary and run your own workload; that number is the only one that matters.