run

run

Polyglot command runner & smart REPL that lets you script, compile, and iterate in 25+ languages without touching another CLI.

Latest release Release passing Docs passing crates.io Downloads GitHub stars Platform support License

Website • Docs Overview

Built in Rust for developers who live in multiple runtimes. run gives you a consistent CLI, persistent REPLs, and batteries-included examples for your favorite languages.

Run 2.0 (Experimental)

Run 2.0 adds WASI 0.2 component support for cross-language composition, instant startup, and edge deployment.

run v2 --help

Quick Links:

See Run 2.0 Documentation below for details.

Table of contents - [Website and Docs](#website-and-docs) - [Overview](#overview---universal-multi-language-runner) - [What is run?](#what-is-run) - [Who is this for?](#who-is-this-for) - [Why was run created?](#why-was-run-created) - [Why Rust?](#why-rust) - [Quickstart](#quickstart) - [Installation](#installation) - [How it works](#how-it-works) - [Supported languages](#supported-languages) - [Complete Language Aliases Reference](#complete-language-aliases-reference) - [Command Variations - Flexible Syntax](#command-variations---flexible-syntax) - [Command-Line Flags Reference](#command-line-flags-reference) - [When to Use --lang](#️-when-to-use---lang-important) - [Main Function Flexibility](#main-function-flexibility) - [Examples](#examples) - [REPL](#repl) - [Interactive REPL - Line by Line or Paste All](#interactive-repl---line-by-line-or-paste-all) - [Variable Persistence & Language Switching](#variable-persistence--language-switching) - [REPL Commands](#repl-commands) - [Stdin Piping Examples](#stdin-piping-examples) - [Language-Specific Notes](#language-specific-notes) - [Run 2.0 - WASI Component Runtime](#run-20---wasi-component-runtime) - [License](#license)

Website and Docs

The official website and full documentation are available here:

Use these links to explore features, language guides, and detailed examples.

Overview - Universal Multi-Language Runner

A powerful command-line tool for executing code in 25 programming languages

What is run?

run is a universal multi-language runner and smart REPL (Read-Eval-Print Loop) written in Rust. It provides a unified interface for executing code across 25 programming languages without the hassle of managing multiple compilers, interpreters, or build tools.

Whether you’re a beginner learning your first programming language or an experienced polyglot developer, run streamlines your workflow by providing consistent commands and behavior across all supported languages.

Who is this for?

Why was run created?

Traditional development workflows require installing and configuring separate tools for each programming language. This creates several problems:

run solves these problems by providing a single, unified interface that handles all the complexity behind the scenes. You focus on writing code, and run takes care of the rest.

Why Rust?

run is built with Rust for several compelling reasons:

Quickstart

# Show build metadata for the current binary
run --version

# Execute a snippet explicitly
run --lang python --code "print('hello, polyglot world!')"

# Let run detect language from the file extension
run examples/go/hello/main.go

# Drop into the interactive REPL (type :help inside)
run

# Pipe stdin (here: JSON) into Node.js
echo '{"name":"Ada"}' | run js --code "const data = JSON.parse(require('fs').readFileSync(0, 'utf8')); console.log(\`hi \${data.name}\`)"

# Pipe stdin into Python
echo "Hello from stdin" | run python --code "import sys; print(sys.stdin.read().strip().upper())"

# Pipe stdin into Go
echo "world" | run go --code 'import "fmt"; import "bufio"; import "os"; scanner := bufio.NewScanner(os.Stdin); scanner.Scan(); fmt.Printf("Hello, %s!\n", scanner.Text())'

Installation

All release assets are published on the GitHub Releases page, including macOS builds for both Apple Silicon (arm64) and Intel (x86_64). Pick the method that fits your platform:

Cargo (Rust) ```bash cargo install run-kit ``` > Installs the `run` binary from the [`run-kit`](https://crates.io/crates/run-kit) crate. Updating? Run `cargo install run-kit --force`. ```bash # Or build from source git clone https://github.com/Esubaalew/run.git cd run cargo install --path . ``` > This builds the run binary using your active Rust toolchain. The project targets Rust 1.70 or newer.
Homebrew (macOS) ```bash brew install --formula https://github.com/Esubaalew/run/releases/latest/download/homebrew-run.rb ``` > This formula is published as a standalone file on each release; it isn't part of the default Homebrew taps.
Debian / Ubuntu ```bash ARCH=${ARCH:-amd64} DEB_FILE=$(curl -s https://api.github.com/repos/Esubaalew/run/releases/latest \ | grep -oE "run_[0-9.]+_${ARCH}\\.deb" | head -n 1) curl -LO "https://github.com/Esubaalew/run/releases/latest/download/${DEB_FILE}" curl -LO "https://github.com/Esubaalew/run/releases/latest/download/${DEB_FILE}.sha256" sha256sum --check "${DEB_FILE}.sha256" sudo apt install "./${DEB_FILE}" ```
Windows (Scoop) ```powershell scoop install https://github.com/Esubaalew/run/releases/latest/download/run-scoop.json ```
Install script (macOS / Linux) ```bash curl -fsSLO https://raw.githubusercontent.com/Esubaalew/run/master/scripts/install.sh chmod +x install.sh ./install.sh --add-path ``` Pass `--version v0.2.0`, `--prefix /usr/local/bin`, or `--repo yourname/run` to customize the install.

Verify installation:

run --version

How it works

run shells out to real toolchains under the hood. Each LanguageEngine implements a small trait that knows how to:

  1. Detect whether the toolchain is available (e.g. python3, go, rustc).
  2. Prepare a temporary workspace (compilation for compiled languages, transient scripts for interpreters).
  3. Execute snippets, files, or stdin streams and surface stdout/stderr consistently.
  4. Manage session state for the interactive REPL (persistent modules, stateful scripts, or regenerated translation units).

This architecture keeps the core lightweight while making it easy to add new runtimes or swap implementations.

Supported languages

run supports 25 programming languages out of the box:

Category Languages & aliases Toolchain expectations
Scripting & shells Bash (bash), Python (py, python), Ruby (rb, ruby), PHP (php), Perl (perl), Groovy (groovy, grv), Lua (lua), R (r), Elixir (ex, elixir) Matching interpreter on PATH
Web & typed scripting JavaScript (js, node), TypeScript (ts, deno), Dart (dart), Kotlin (kt, kotlin) node, deno, dart, kotlinc + JRE
Systems & compiled C (c), C++ (cpp, cxx), Rust (rs, rust), Go (go), Swift (swift), Zig (zig), Nim (nim), Haskell (hs, haskell), Crystal (cr, crystal), C# (cs, csharp), Java (java), Julia (jl, julia) Respective compiler / toolchain

Complete Language Aliases Reference

Alias Description Badge
python, py, py3, python3 Python programming language Python
javascript, js, node, nodejs JavaScript (Node.js runtime) JavaScript
typescript, ts, ts-node, deno TypeScript with type checking TypeScript
rust, rs Rust systems programming language Rust
go, golang Go programming language Go
c, gcc, clang C programming language C
cpp, c++, g++ C++ programming language C++
java Java programming language Java
csharp, cs, dotnet C# (.NET) C#
ruby, rb, irb Ruby programming language Ruby
bash, sh, shell, zsh Bash shell scripting Bash
lua, luajit Lua scripting language Lua
perl, pl Perl programming language Perl
groovy, grv, groovysh Groovy on the JVM Groovy
php, php-cli PHP scripting language PHP
haskell, hs, ghci Haskell functional language Haskell
elixir, ex, exs, iex Elixir functional language Elixir
julia, jl Julia scientific computing Julia
dart, dartlang, flutter Dart language (Flutter) Dart
swift, swiftlang Swift programming language Swift
kotlin, kt, kts Kotlin (JVM/Native) Kotlin
r, rscript, cran R statistical computing R
crystal, cr, crystal-lang Crystal language Crystal
zig, ziglang Zig systems language Zig
nim, nimlang Nim programming language Nim

Command Variations - Flexible Syntax

run supports multiple command formats:

# Full syntax
run --lang rust --code "fn main() { println!(\"hello\"); }"

# Shorthand flags
run -l rust -c "fn main() { println!(\"hello\"); }"

# Language first, then code
run rust "fn main() { println!(\"hello\"); }"

# Auto-detect from file
run examples/rust/hello.rs

Command-Line Flags Reference

--lang, -l          Specify the programming language
--code, -c          Provide code as a string

run -l python -c "print('hello')"
run --lang python --code "print('hello')"

When to Use –lang (Important!)

Always use --lang when syntax is ambiguous:

# Ambiguous - may choose wrong language
run "print('hello')"

# Explicit - always correct
run --lang python "print('hello')"

Main Function Flexibility

For compiled languages, run is smart about main functions:

$ run go
go>>> fmt.Println("Hello, world!")
Hello, world!

go>>> package main
import "fmt"
func main() { fmt.Println("Hello!") }
Hello!

Examples

Real programs live under the examples/ tree:

run examples/rust/hello.rs
run examples/typescript/progress.ts
run examples/python/counter.py

REPL

The REPL supports built-in commands:

Command Purpose
:help List available meta commands
:languages Show detected engines and status
:lang <id> or :<alias> Switch the active language (:py, :go, …)
:detect on/off/toggle Control snippet language auto-detection
:load path/to/file Execute a file inside the current session
:reset Clear the accumulated session state
:exit / :quit Leave the REPL

Interactive REPL - Line by Line or Paste All

$ run python
python>>> def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")

Variable Persistence & Language Switching

$ run go
go>>> x := 10
go>>> x
10

go>>> :py
switched to python

python>>> y = 10
python>>> print(y)
10

Stdin Piping Examples

# Node.js (JSON Processing)
echo '{"name":"Ada"}' | run js --code "const data = JSON.parse(require('fs').readFileSync(0, 'utf8')); console.log(\`hi \${data.name}\`)"

# Python (Uppercase)
echo "Hello" | run python --code "import sys; print(sys.stdin.read().strip().upper())"

# Go (Greeting)
echo "world" | run go --code 'import "fmt"; import "bufio"; import "os"; scanner := bufio.NewScanner(os.Stdin); scanner.Scan(); fmt.Printf("Hello, %s!\n", scanner.Text())'

Language-Specific Notes

For detailed usage and best practices for each language, visit the documentation.

Run 2.0 - WASI Component Runtime

Run 2.0 is an experimental extension that adds WASI 0.2 component support. It is opt-in and does not replace Run 1.0.

What Run 2.0 Adds

Quick Start

# Install with v2 support
cargo install run-kit --features v2

# See v2 commands
run v2 --help

# Initialize a project
run v2 init my-app
cd my-app

# Build and run
run v2 build
run v2 dev

Run 2.0 Commands

Command Description
run v2 init Initialize a new project
run v2 build Build WASI components
run v2 dev Development server with hot reload
run v2 test Run component tests
run v2 deploy Deploy to edge/registry
run v2 install Install dependencies

Publishing to the Registry

Run 2.0 publishes components via run v2 publish (alias for run v2 deploy --target registry).

Default registry:

Publish a component:

run v2 build
run v2 publish --token YOUR_TOKEN

Override the registry URL:

run v2 publish \
  --registry-url https://registry.esubalew.dev \
  --token YOUR_TOKEN

You can also set the token in run.toml:

[registry]
auth_token = "${RUN_AUTH_TOKEN}"

Keep tokens in environment variables and do not commit them to source control.

Configuration

run.toml defines your project:

[package]
name = "my-app"
version = "1.0.0"

[[component]]
name = "api"
source = "src/lib.rs"
language = "rust"
wit = "wit/api.wit"

[dev]
watch = ["src/**/*.rs"]
hot_reload = true

Resources

License

Apache 2.0. See LICENSE for details.

Built with Rust. If run helps your workflow, star the repo and share it with other polyglot developers.

This site is open source. Improve this page.