Run is a versatile tool designed to execute code snippets, scripts, and interactive sessions across 25+ programming languages. Built in Rust, Run offers a consistent CLI and persistent REPLs, allowing developers to work seamlessly across different languages without managing multiple tools.
Key Features:
Rust Foundation: Ensures high performance, reliability, and cross-platform compatibility.
Multi-Language Support: Executes code in over 25 languages with a unified interface.
Persistent REPL: Maintains variables and allows language switching within the same session.
WASI Component Runtime: Facilitates cross-language composition and edge deployment.
Cross-Platform Availability: Works on Windows, macOS, and Linux.
Audience & Benefit:
Ideal for developers, DevOps engineers, educators, students, and beginners, Run simplifies workflows by reducing the need for multiple tools. It enables rapid prototyping, efficient testing, and seamless language switching, enhancing productivity and focus on coding rather than setup.
Installation is straightforward via winget, making it accessible and easy to integrate into any development environment.
README
run
Polyglot command runner & smart REPL that lets you script, compile, and iterate in 25+ languages without touching another CLI.
> 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.
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?
Beginners: Learn programming without worrying about complex setup procedures. Just install run and start coding in any language.
Students: Quickly test code snippets and experiment with different programming paradigms across multiple languages.
Developers: Prototype ideas rapidly, test algorithms, and switch between languages seamlessly without context switching.
DevOps Engineers: Write and test automation scripts in various languages from a single tool.
Educators: Teach programming concepts across multiple languages with a consistent interface.
Why was run created?
Traditional development workflows require installing and configuring separate tools for each programming language. This creates several problems:
Time-consuming setup: Installing compilers, interpreters, package managers, and configuring environments for each language.
Inconsistent interfaces: Each language has different commands and flags for compilation and execution.
Cognitive overhead: Remembering different commands and workflows for each language.
Barrier to entry: Beginners struggle with setup before writing their first line of code.
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:
Performance: Rust's zero-cost abstractions and efficient memory management ensure run starts instantly and executes with minimal overhead.
Reliability: Rust's strong type system and ownership model prevent common bugs like null pointer dereferences and data races, making run stable and crash-resistant.
Cross-platform: Rust compiles to native code for Windows, macOS, and Linux, providing consistent behavior across all platforms.
Memory safety: No garbage collector means predictable performance without unexpected pauses.
Modern tooling: Cargo (Rust's package manager) makes building and distributing run straightforward.
Future-proof: Rust's growing ecosystem and industry adoption ensure long-term maintainability.
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)
cargo install run-kit
> Installs the run binary from the run-kit crate. Updating? Run cargo install run-kit --force.
# 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.
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
javascript, js, node, nodejs
JavaScript (Node.js runtime)
typescript, ts, ts-node, deno
TypeScript with type checking
rust, rs
Rust systems programming language
go, golang
Go programming language
c, gcc, clang
C programming language
cpp, c++, g++
C++ programming language
java
Java programming language
csharp, cs, dotnet
C# (.NET)
ruby, rb, irb
Ruby programming language
bash, sh, shell, zsh
Bash shell scripting
lua, luajit
Lua scripting language
perl, pl
Perl programming language
groovy, grv, groovysh
Groovy on the JVM
php, php-cli
PHP scripting language
haskell, hs, ghci
Haskell functional language
elixir, ex, exs, iex
Elixir functional language
julia, jl
Julia scientific computing
dart, dartlang, flutter
Dart language (Flutter)
swift, swiftlang
Swift programming language
kotlin, kt, kts
Kotlin (JVM/Native)
r, rscript, cran
R statistical computing
crystal, cr, crystal-lang
Crystal language
zig, ziglang
Zig systems language
nim, nimlang
Nim programming language
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!
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 or :
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
Cross-language composition: Rust, Python, Go, JS components calling each other via WIT interfaces
Hermetic builds: Reproducible builds with toolchain lockfiles
Edge deployment: Deploy to Cloudflare Workers, AWS Lambda, Vercel
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:
https://registry.esubalew.dev
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
