Log inSubmit server
Runno logo

Runno

Run code in supported WebAssembly-based languages through an MCP-connected sandbox.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Runno

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "runno": {
      "command": "npx",
      "args": [
        "@runno/mcp"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

We couldn’t confirm it starts correctly

The install command didn't complete successfully in our automated test.

npx @runno/mcp

e! 10.1.0 -> 12.2.0 npm notice Changelog: <https://github.com/npm/cli/releases/tag/v12.2.0> npm notice Run `npm install -g npm@12.2.0` to update! npm notice npm ERR! code ETARGET npm ERR! notarget No matching version found for @runno/sandbox@^0.10.3. npm ERR! notarget In most cases you or one of your dependencies are requesting npm ERR! notarget a package version that doesn't exist. npm ERR! A complete log of this run can be found in: /home/user/.npm/_logs/2026-10-21T11_36_39_360Z-debug-0.log

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 3d ago.

Overview

The runno MCP server exposes Runno's sandbox for executing code from MCP clients. It runs supported language runtimes inside a JavaScript and WASI-based sandbox, with output returned from execution. Use it for small code examples, teaching exercises, and checks that primarily use standard input and output. Configure it as a stdio server with npx.

Use cases

  • Run small Python or Ruby examples from an MCP client
  • Check introductory programming exercises using standard input and output
  • Execute SQLite commands in a sandboxed runtime
  • Test C or C++ snippets without a local compiler
  • Inspect code execution results from an agent workflow

Key features

  • MCP access to Runno's sandbox
  • WebAssembly and WASI-based execution
  • Python, Ruby, QuickJS, SQLite, C, C++, and PHP CGI runtimes
  • Captured standard output and execution results
  • Virtual filesystem support in the underlying sandbox
  • Local stdio configuration through npx

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked Today

Recent health check succeeded.

7/7 checks healthy over the last 47d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 9d ago via OSV.dev · @runno/mcp (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars775Stargazers on the source repository.
npm downloads90Package downloads in the last 30 days.
Last commit2mo agoMost recent push to the default branch.
Install checkInconclusiveInstall command did not finish in our automated test.
Directory activity1 viewsConfig copies, upvotes, and views on AllMCPs.

How Runno works

What runno does

The runno MCP server connects an MCP client to Runno's sandbox package, allowing an agent to request code execution without installing a native compiler or interpreter for each supported language. Runno uses WebAssembly and WASI to provide a Unix-like execution environment inside JavaScript.

Supported runtimes include Python 3, Ruby, QuickJS JavaScript, SQLite, C through Clang, C++ through Clang++, and PHP CGI. The exact Python and Ruby versions are not pinned; the documented minimums are Python 3.6 and Ruby 3.2.0. The package also supports running WASI binaries, although the MCP package is described specifically as being built on @runno/sandbox.

How it works

The server is implemented in the repository's @runno/mcp package and uses the sandbox package to run submitted programs. WebAssembly emulates the system interfaces that programs need, including a virtual filesystem and terminal-style input and output. Results from the underlying sandbox include execution status and captured output such as stdout.

The standard configuration launches the server through npx, so an MCP client starts it as a local process and communicates with it over the client's MCP transport.

Setup and configuration

Add the server to an MCP client's configuration as a command-based server:

config.json
{
  "mcpServers": {
    "runno": {
      "command": "npx",
      "args": ["@runno/mcp"]
    }
  }
}

The repository does not document required environment variables, API keys, or additional settings for this configuration. The package must be available through npm, and the client must support launching a stdio MCP server.

Tools and capabilities

The runno MCP server is suited to code-execution requests involving the runtimes provided by Runno:

  • Execute Python, Ruby, QuickJS, SQLite, C, C++, or PHP CGI code.
  • Capture program output for an MCP client to inspect.
  • Run code against Runno's sandboxed JavaScript/WASI environment.
  • Use the underlying sandbox's virtual filesystem support where exposed by the MCP implementation.
  • Run small programs that communicate through standard input and standard output.

Check the package documentation or inspect the server implementation before depending on a particular tool name or argument shape.

Limitations and notes

Runno's available languages depend on tools compiled to WebAssembly with WASI. WASI is not a complete Linux environment, so system-level interfaces may not work. Installing packages or modules inside the environment is difficult; code that needs imports may need those files supplied with the example.

The project describes the runno MCP server's underlying runtime as best suited to small examples using stdin and stdout, including introductory computer-science exercises. It should not be assumed to provide unrestricted operating-system access, arbitrary native package installation, or a full server host environment.

The repository states that Runno is released under the MIT License and provides no warranty.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Runno

runno is an MCP server that connects MCP clients to Runno's WebAssembly- and WASI-based sandbox. Its main capabilities are executing supported Python, Ruby, QuickJS, SQLite, C, C++, and PHP CGI code, returning execution results and output, and using the sandbox's virtual filesystem where supported.

Install it by configuring your MCP client to launch `npx @runno/mcp`.

Runno supports Python, Ruby, QuickJS JavaScript, SQLite, C, C++, and PHP CGI. Python is at least version 3.6 and Ruby is at least version 3.2.0, but the documentation does not pin their exact runtime versions.

Runno is best used for small sandboxed programs that rely on standard input and standard output, such as introductory programming exercises and code examples. Its WASI environment is not a full Linux system, and installing packages or modules can be difficult.

Runno can work with Cursor if Cursor supports configuring and launching a standard stdio MCP server.

Related MCP servers

All in Code Execution All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewRunno AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/runno?style=directory)](https://allmcps.com/mcp/runno)
HTML Embed
<a href="https://allmcps.com/mcp/runno"><img src="https://allmcps.com/api/badge/runno?style=directory" alt="Runno on AllMCPs" /></a>