Runno MCP Server enables secure code execution in multiple programming languages using WebAssembly WASI sandboxing. It provides a controlled environment for running Python, Ruby, JavaScript (via QuickJS), SQLite, and C code without requiring external toolchains or installations. Key capabilities: - Multi-language code execution: Python, Ruby, QuickJS (JavaScript), SQLite, and Clang (C) - WASI-based sandboxing that emulates file systems and operating systems within JavaScript - Isolated runtime environment for safe, controlled code execution - Support for interactive programs with STDIN handling via SharedArrayBuffer - Works entirely in-browser or in Node.js/JavaScript runtimes without server-side infrastructure

👨‍💻 Use Runno 👉 Runno.dev

📖 Documentation 👉 Runno.dev

Runno

Runno is a collection of JavaScript Packages for running code in various languages inside a sandbox. It's made of the following packages:

There's also a deprecated Python package called runno that works like the sandbox package.

This project is powered by WASI the Web Assembly System Interface. It provides a standard way for programs to interact with an operating system. By emulating this interface, we can provide a fake file system and operating system, all running within JavaScript.

Using @runno/runtime

The @runno/runtime package provides Web Components for running code in the browser.

This is very handy for programming education it means:

Quickstart

Start by adding @runno/runtime to your package:

npm install @runno/runtime

Import @runno/runtime in whatever place you'll be using the runno elements. The simplest is in your entrypoint file (e.g. main.ts or index.ts).

import "@runno/runtime";

Once you've imported them you can use runno elements on the page.

 print('Hello, World!') 

For the code to run though, you'll need to set some HTTP headers:

Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp

These create a cross-origin isolated context which allows the use of SharedArrayBuffer used to implement STDIN.

Supported Runtimes

The system supports a number of runtimes based on existing packages published to WAPM. These runtimes are tied to Runno and will be supported by Runno going forward.

Running WASI binaries

The runtime also provides a component for running WASI binaries directly.

Examples

There are more examples for how to use Runno in the examples directory in this repo. It includes practical ways you can use Runno, and how to configure it to run.

Full documentation

Visit @runno/runtime to read the full documentation.

How does it work?

Runno uses Web Assembly to run code from JavaScript. Code runs in a unix-like sandbox that connects to a web-based terminal emulator. This means it behaves a lot like running code natively on a linux terminal. It's not perfect, but it's handy for making code examples run.

Plus it's pretty cool that you can just run code in your browser!

Using @runno/sandbox

Quickstart

Install the sandbox with npm install @runno/sandbox. Then use it to run code like:

import { runCode } from "@runno/sandbox";
const result = await runCode("ruby", "puts 'Hello, world!'");
if (result.resultType === "complete") {
  console.log(result.stdout);
} else {
  console.log("Oh no!");
}

You can also do more complicated things, like run against a virtual file system with runFS:

function runFS(
  runtime: Runtime,
  entryPath: string,
  fs: WASIFS,
  options?: {
    stdin?: string;
    timeout?: number;
  },
): Promise;

Using @runno/wasi

Quickstart

The quickest way to get started with Runno is by using the WASI.start class method. It will set up everything you need and run the Wasm binary directly.

Be aware that this will run on the main thread, not inside a worker. So you will interrupt any interactive use of the browser until it completes.

```js import { WASI } from "@runno/wasi";

//...

const result = WASI.start(fetch("/binary.wasm"), {