---
title: Quickstart
description: Get a sandbox running in under 5 minutes
icon: "bolt"
---
## Run your first sandbox
```bash npx
npx microsandbox run debian
```
```bash macOS & Linux
curl -fsSL https://install.microsandbox.dev | sh
msb run debian
```
```powershell Windows
irm https://install.microsandbox.dev/windows | iex
msb run debian
```
Prefer short commands such as `msb run debian` for everyday use. `msb sandbox run debian` and `msb sbx run debian` do the same thing, with the same flags. Explore the full group with `msb sandbox --help`.
Having trouble with a local installation? Choose your platform for setup checks and fixes.
For application code, install the SDK for your language. For terminal workflows, use one of the CLI options above. Both run microsandbox locally by default; there is no separate server or daemon to set up. The same installation also drives [microsandbox cloud](/cloud/overview) when an API key is set.
```bash TypeScript
npm install microsandbox
```
```bash Rust
cargo add microsandbox
```
```bash Python
pip install microsandbox
```
```bash Go
go get github.com/superradcompany/microsandbox/sdk/go
```
```bash Ruby
gem install microsandbox
```
You can also provision the runtime with the CLI installer above or explicit SDK setup helpers. See [Runtime setup](/sdk/setup#bring-your-own-runtime) for Node's bundled binaries and Rust's opt-out options.
Check local virtualization support with:
```bash
msb doctor
```
For platform-specific setup notes, see [Linux troubleshooting](/troubleshooting/linux), [macOS troubleshooting](/troubleshooting/macos), or [Windows troubleshooting](/troubleshooting/windows).
Create a sandbox, execute code inside it, and get the result back.
```typescript TypeScript
import { Sandbox } from "microsandbox";
await using sb = await Sandbox.builder("hello")
.image("python")
.memory(512)
.create();
const output = await sb.exec("python", ["-c", "print('Hello from a microVM!')"]);
console.log(output.stdout()); // Hello from a microVM!
```
```rust Rust
use microsandbox::Sandbox;
#[tokio::main]
async fn main() -> Result<(), Box> {
let sb = Sandbox::builder("hello")
.image("python")
.memory(512)
.create()
.await?;
let output = sb.exec("python", ["-c", "print('Hello from a microVM!')"]).await?;
println!("{}", output.stdout()?); // Hello from a microVM!
sb.stop().await?;
Ok(())
}
```
```python Python
import asyncio
from microsandbox import Sandbox
async def main():
sb = await Sandbox.create(
"hello",
image="python",
memory=512,
)
output = await sb.exec("python", ["-c", "print('Hello from a microVM!')"])
print(output.stdout_text) # Hello from a microVM!
await sb.stop()
asyncio.run(main())
```
```go Go
sb, err := m.CreateSandbox(ctx, "hello",
m.WithImage("python"),
m.WithMemory(512),
)
if err != nil {
return err
}
defer sb.Stop(ctx)
output, err := sb.Exec(ctx, "python", []string{"-c", "print('Hello from a microVM!')"})
if err != nil {
return err
}
fmt.Println(output.Stdout()) // Hello from a microVM!
```
```ruby Ruby
require "microsandbox"
Microsandbox.install unless Microsandbox.installed?
Microsandbox::Sandbox.with("hello", image: "python", memory: 512) do |sandbox|
output = sandbox.exec("python", ["-c", "print('Hello from a microVM!')"])
puts output.stdout
end
```
```bash CLI
msb run python -- python3 -c "print('Hello from a microVM!')"
```
## What just happened?
Here's what happened behind that `Sandbox.builder(...).create()` call:
1. **Pulled the image** from Docker Hub, unless it was already cached.
2. **Assembled a copy-on-write filesystem** so changes inside the sandbox do not modify the base image.
3. **Booted a microVM** as a child process with the resource limits you configured.
4. **Started the guest agent** so the SDK can run commands and move data in and out.
The `exec` call uses the host-guest command channel, not SSH and not the sandbox network.
Want the same sandbox on hosted infrastructure? Set `MSB_BACKEND=cloud` and export `MSB_API_KEY`; the code above then runs on [microsandbox cloud](/cloud/overview) unchanged.
## Next steps
- [Explore practical examples](/examples/overview): tested workflows for agents, CI/CD, Docker, automation, and more
- [Run on microsandbox cloud](/cloud/overview): the same code on hosted infrastructure
- [Modify live sandbox settings](/sandboxes/tuning): resize headroom, labels, secrets, and storage
- [Troubleshoot Linux setup](/troubleshooting/linux): KVM, `/dev/kvm`, and permissions
- [Troubleshoot macOS setup](/troubleshooting/macos): Apple Silicon and local runtime checks
- [Troubleshoot Windows setup](/troubleshooting/windows): WHP, `msb doctor`, and runtime setup
- [Run commands and stream output](/sandboxes/commands): `exec`, `shell`, `attach`, and streaming
- [Control network access](/networking/overview): policies, DNS interception, and secret protection
- [Manage sandboxes with the CLI](/cli/overview): create, inspect, and manage sandboxes from the terminal