VoidLang
About
VoidLang - LLM Native Machine Code MCP
Details
- Author
- 24greyhat
- Categories
- Developer Tools, AI, Other
Jump to
Setup
Install VoidLang in your MCP client (Claude Desktop, Cursor, Windsurf, and others).
Repository: https://github.com/24greyhat/voidLang
Follow the installation instructions in the repository README, then restart your MCP client.
┌──────────────────────────────────────────────────────────────────────┐ │ LLM ──[opcode JSON]──▶ voidmcp ──▶ Go / React / Swift / Kotlin │ │ │ │ │ └──▶ go build / npm build │ │ │ │ ──▶ artifact URL (binary / zip) │ └──────────────────────────────────────────────────────────────────────┘
- 9 compilation targets:linux,macos,windows,ios,android,web,pwa,wasm,docker.
- ~160 opcodes covering HTTP, SQL, Redis, JWT, bcrypt, web UI, mobile UI, file IO, and Docker topology.
- One-shot ISA endpoint returns theentireinstruction set in one call — no per-call schema discovery.
- Two transports: HTTP (any LLM, any IDE, any agent) and MCP stdio JSON-RPC (Claude Desktop / Claude Code).
- Production-grade: stdlib-only server, multi-stage Dockerfile, healthcheck, Railway-ready.
LLMs are terrible at writing valid syntax in a brand-new language, but they are excellent at outputting JSON arrays. VoidLang flips the contract: thelanguageis a JSON array of[opcode, args…]pairs. The compiler does all of the work — formatting, imports, error handling, deployment topology — so the model only has to expressintent, not boilerplate.
A web API that talks to Postgres, authenticates with JWT, has CRUD on two tables, and deploys to Docker compose, fits in~80 instructions. A handwritten Go version of the same app is ~1500 lines.
make build && ./build/voidmcp --addr :7070
Openhttp://localhost:7070for the landing page, or hit any endpoint:
curl -s http://localhost:7070/isa | jq '.opcodes | length' # → ~95
curl -sX POST http://localhost:7070/compile \ -H 'Content-Type: application/json' \ -d '{"void": { "v": 1, "name": "hello", "tgt": ["linux"], "ins": [ [1, "hello"], [3, "linux"], [242, "Hello from VoidLang!"] ] }}' | jq .
The response contains the generated Go source, ago.mod, and (ifgois on the server's PATH) a URL to download the compiled binary.
Or run it as a Claude Desktop / Claude Code MCP server
Add to~/.config/claude/claude_desktop_config.json(or equivalent):
{ "mcpServers": { "voidlang": { "command": "/absolute/path/to/build/voidmcp", "args": ["stdio"] } } }
Claude will see four tools:isa,isa_quick,targets,compile.
// request { "void": { "v": 1, "name": "todo_api", "tgt": ["linux", "docker"], "ins": [/…/] }, "target": "linux", // optional override "name": "todo_api" // optional override } // response { "ok": true, "app": "todo_api", "targets": [ { "target": "linux", "kind": "binary", "binary_size": 9482240, "download_url": "http://localhost:7070/artifacts/3f6a2b1c8e9d4f70", "files": { "main.go": "…", "go.mod": "…" } }, { "target": "docker-compose", "kind": "text", "files": { "docker-compose.yml": "…", ".env.example": "…", "Dockerfile": "…" } } ] }
Disabled by default. SetVOIDMCP_ALLOW_RUN=1on the server to enable. The server will compileand executethe generated binary, returning stdout/stderr/exit code.Do not enable this on a public Railway deployment— only use it on a sandbox where running arbitrary code is safe.
The repo ships with aDockerfile, arailway.json, and anixpacks.tomlfallback. To deploy:
# install the Railway CLI once npm i -g @railway/cli railway login # inside this repo railway init # pick "Empty Project" railway up # builds + deploys the Dockerfile railway domain # mint a public URL
The healthcheck path (/health) is wired throughrailway.json, so Railway will fail-fast if the server can't boot.
curl https://your-app.up.railway.app/isa | jq '.opcodes | length'
The repo isMIT-licensed, so you're free to deploy it as a paid SaaS. A common pattern:
- Put an API gateway (e.g. Kong, Cloudflare Workers, or a tiny proxy service) in front ofvoidmcp. Authenticate by API key. Meter/compilecalls per key.
- Charge per-compile or per-month per-LLM-agent. The cost basis is the ~50–500 ms of CPU each call uses; priceoutput value(a working binary), not CPU time.
- Optional: rate-limit/compilewith a Redis-backed sliding window (the ISA exposes the opcodes you'd need to build this in VoidLang itself, recursively).
- Free tier idea:/isa,/isa/quick,/targetsare read-only and cheap — leave them unauthenticated to maximise model adoption.
- Once per session:GET /isa— load the entire instruction set into the model's context. ~30k tokens. (OrGET /isa/quickfor ~2k.)
- For each user request: emit a void file as a JSON object, send toPOST /compile. Stream the response back to the user with a download link.
- Optional refinement: if the LLM made a mistake, the server returnsbuild_logwith the Go compiler's diagnostic. Feed it back to the LLM and ask for a fixed instruction array.
A complete system prompt template is indocs/LLM_PROMPT.md.
- examples/hello.void— minimal Hello World.
- examples/todo_api.void— full CRUD API with Postgres + JWT auth + docker-compose.
voidLang/ ├── cmd/voidmcp/ main entrypoint (HTTP + stdio mode) ├── internal/ │ ├── isa/ opcode definitions + metadata │ ├── void/ .void file decoder │ ├── codegen/ │ │ ├── golang/ Go backend (linux/macos/windows/docker/wasm seed) │ │ ├── web/ React + Vite project generator │ │ ├── mobile/ iOS (SwiftUI) + Android (Compose) scaffolds │ │ ├── wasm/ WebAssembly build helper │ │ └── docker/ docker-compose.yml generator │ └── mcp/ HTTP server + stdio JSON-RPC transport ├── examples/ sample .void files ├── docs/ ISA reference, deployment, LLM prompt template ├── Dockerfile multi-stage build for production ├── railway.json Railway deploy config ├── nixpacks.toml Railway nixpacks fallback ├── Makefile build / run / docker helpers └── go.mod stdlib-only (no external deps)
The server haszero external Go dependencies. Thegeneratedprograms do depend ongin,pgx,go-redis,golang-jwt, andx/crypto— those get downloaded on first compile and cached.
make dev # run via go run (no install) make stdio # run MCP stdio mode make test # run unit tests make fmt # gofmt make docker-run # full Dockerised cycle
The server itself is stateless aside from a 30-minute in-memory cache of compiled artifacts (so/artifacts/{id}links don't expire too fast). Restart-and-go.
- docs/ISA.md— opcode-by-opcode reference.
- docs/LLM_PROMPT.md— drop-in system prompt for any LLM.
- docs/DEPLOY.md— Railway / Fly / bare-VM deploy notes.
This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.
Automatically generates documentation for code repositories by analyzing directory structures and code files using the OpenRouter API.
Provides fast C++ code intelligence for LLMs using the clangd language server.
Diagnoses token waste in Claude Code sessions with 6 anomaly types and severity scoring. Fully local.
A server for code modification and generation using Large Language Models.
Your AI Code Review Council - Get diverse perspectives from multiple AI models in parallel.
CLI token optimizer and AI context generator with built-in MCP server. Scans codebases to extract routes, schema, components, and dependencies 9x–13x token reduction for Claude Code, Cursor, Copilot, Codex, and Windsurf.
An MCP server for the codetoprompt library, enabling integration with LLM agents.
An MCP server that wraps the OpenAI Codex CLI, exposing its functionality through the MCP API.
A coding assistant server that provides context-aware code suggestions, documentation integration, and technology detection.
Rewrites coding prompts for optimal results with AI IDEs like Cursor AI, powered by Claude by Anthropic.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
