# runno [Health: Active]

**Category:** 👨‍💻 Code Execution  
**Repository:** https://github.com/taybenlor/runno  
**GitHub Stars:** 775  
**npm Downloads (last month):** 90  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/runno

## Description
Sandboxed runtime for programming languages and WASI binaries. Works in the browser, on your server, or via MCP.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

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

## Documentation

## 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:

```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.

_Full upstream README: https://allmcps.com/mcp/runno/readme_