DEV Community

Cover image for Realm: The Dev Environment That Eliminates Terminal Chaos
Wess Cope
Wess Cope

Posted on

Realm: The Dev Environment That Eliminates Terminal Chaos

#devtools #rust #productivity #webdev

I have been using this little tool for a bit because I don't always get to have docker in some of the specialized environments or platforms I build for. I decided to polish it up and release it.

The Problem: Development Environment Chaos

Modern full-stack development is surprisingly complex:

  • Multiple terminals: Frontend on port 3000, API on 4000, docs on 8080
  • Runtime management: Node 18 for one project, Node 20 for another
  • Proxy configuration: Manually configuring nginx or setting up CORS
  • Environment isolation: Global package pollution and version conflicts
  • Process orchestration: Remembering which services to start in which order

This complexity multiplies when you're working on multiple projects. Context switching becomes painful, and onboarding new developers means sharing a 50-step setup guide.

What is Realm?

Realm is a single CLI tool that replaces your entire development environment setup. It combines:

  • Virtualenv-like environments for complete project isolation
  • Built-in process manager (like Foreman) with intelligent routing
  • Multi-runtime support (Bun, Node.js, Python, Deno, Go)
  • Zero-config proxy server that routes requests to your services
  • Project templates to eliminate boilerplate
  • One-command deployment with Docker generation

All written in Rust for speed and reliability.

Installation

Getting started is simple:

# Using cargo cargo install realmenv # Or using the install script curl -sSfL https://github.com/wess/realm/releases/latest/download/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Pre-built binaries are available for macOS (Intel & Apple Silicon), Linux (x64 & ARM64), and Windows.

Quick Start: From Zero to Running in 30 Seconds

The interactive init experience makes setup effortless:

# Initialize with prompts realm init # Follow the prompts: # → Project name: myapp # → Select runtime: Bun (latest) # → Use a template?: React + Express # → Done! cd myapp source .venv/bin/activate realm start # Visit http://localhost:8000 - it just works!
Enter fullscreen mode Exit fullscreen mode

That's it. No webpack config, no proxy setup, no port juggling. Everything runs on http://localhost:8000 with intelligent routing.

The Magic: How Realm Works

Realm acts as a single command center for your entire development environment:

┌─────────────────────────────────────────────┐ │ Realm CLI │ ├─────────────────────────────────────────────┤ │ Proxy Server (port 8000) │ │ ├── Route: /api/* → backend:4001 │ │ ├── Route: / → frontend:4000 │ │ └── Route: /health → built-in │ ├─────────────────────────────────────────────┤ │ Process Manager │ │ ├── frontend: bun run dev │ │ ├── backend: bun run server │ │ └── docs: bun run docs │ ├─────────────────────────────────────────────┤ │ Runtime Manager │ │ ├── Bun 1.0.1 (per project) │ │ └── Node.js 20.5.0 (per project) │ ├─────────────────────────────────────────────┤ │ Environment Manager │ │ ├── .env file loading │ │ └── Variable isolation │ └─────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

1. Smart Proxy Routing

Instead of manually configuring nginx or dealing with CORS issues, Realm's built-in proxy handles everything:

# realm.yml proxy_port: 8000 processes: frontend: command: "bun run dev" port: 4000 routes: ["/", "/assets/*"] backend: command: "bun run server" port: 4001 routes: ["/api/*", "/health"]
Enter fullscreen mode Exit fullscreen mode

The proxy automatically:

  • Routes requests based on URL patterns
  • Handles WebSocket connections (for HMR, live reload)
  • Adds CORS headers for development
  • Provides health checks

2. Process Management

Like Foreman or Overmind, but integrated with routing:

realm start # Start everything realm stop # Stop everything
Enter fullscreen mode Exit fullscreen mode

All process output is aggregated with colored prefixes, so you can see what's happening across your entire stack.

3. Runtime Isolation

Similar to virtualenv for Python or nvm for Node, but project-scoped:

# Use latest Bun realm init myapp --runtime=bun # Use specific Node.js version realm init myapp --runtime=node@20 # Use Python with complete isolation realm init myapp --runtime=python@3.12
Enter fullscreen mode Exit fullscreen mode

Runtimes are downloaded and cached per-project. No more global version conflicts!

Built-in Templates

Realm includes templates for common full-stack patterns:

  • react-express: React + Express (Bun/Node)
  • react-fastapi: React + FastAPI (Python)
  • svelte-fastify: SvelteKit + Fastify
  • vue-express: Vue 3 + Express
  • nextjs: Next.js 14 full-stack app 
# Create from template realm init myapp --template=react-fastapi --runtime=python@3.12 cd myapp source .venv/bin/activate pip install -r backend/requirements.txt realm start
Enter fullscreen mode Exit fullscreen mode

You can also create your own templates with custom variables:

# template.yaml name: my-stack description: My custom template variables: - name: project_name prompt: "Project name" default: "{{directory_name}}" - name: api_port prompt: "API port" default: "3001"
Enter fullscreen mode Exit fullscreen mode

Production: One Command to Deploy

When you're ready to deploy, Realm generates production-ready Docker artifacts:

realm bundle
Enter fullscreen mode Exit fullscreen mode

This creates a dist/ folder with:

  • Dockerfile: Multi-stage build for all processes
  • docker-compose.yml: Complete service orchestration
  • nginx.conf: Reverse proxy with your routing rules
  • deploy.sh: One-command deployment script

No more wrestling with Docker or deployment configurations.

Real-World Comparison

The Old Way 🔥 

# Terminal 1 cd frontend && npm run dev # Terminal 2 cd backend && npm run server # Terminal 3 nginx -c nginx.conf # Terminal 4 export NODE_ENV=development export API_URL=http://localhost:4001 source .env # Remember all ports, manage processes manually...
Enter fullscreen mode Exit fullscreen mode

The Realm Way ✨ 

realm init myapp --template=react-express source .venv/bin/activate realm start # Everything runs on http://localhost:8000
Enter fullscreen mode Exit fullscreen mode

When Should You Use Realm?

Realm shines when you're:

  • Building full-stack applications with separate frontend/backend
  • Working on multiple projects that need different runtime versions
  • Onboarding developers and want a simple setup experience
  • Tired of managing terminals and proxy configurations
  • Want fast deployment without Docker expertise

Community Runtimes

Beyond the built-in support for Bun, Node, and Python, Realm supports custom runtimes through YAML configuration:

# Add Deno support curl -o ~/.realm/runtimes-config/deno.yaml \ https://raw.githubusercontent.com/wess/realm/main/runtimes/deno.yaml realm init --runtime=deno # Add Go support curl -o ~/.realm/runtimes-config/go.yaml \ https://raw.githubusercontent.com/wess/realm/main/runtimes/go.yaml realm init --runtime=go
Enter fullscreen mode Exit fullscreen mode

Check out the community runtimes for more options.

Under the Hood

Realm is built in Rust with a modular architecture:

  • CLI layer: Command-line interface with clap
  • Config parsing: YAML configuration with serde
  • Runtime management: Version downloads and caching
  • Process management: Lifecycle orchestration
  • Proxy server: HTTP routing with tokio
  • Template engine: Tera-based scaffolding
  • Bundle generator: Docker artifact creation

The entire tool is focused on developer experience: fast startup, clear error messages, and zero configuration when possible.

Feature Comparison

Feature Realm Docker Compose Foreman Create-React-App
Process Management ✅ ✅ ✅ ❌
Built-in Proxy ✅ ❌ ❌ ❌
Runtime Isolation ✅ ✅ ❌ ❌
Project Templates ✅ ❌ ❌ ✅
Production Deploy ✅ ✅ ❌ ✅
Zero Config ✅ ❌ ❌ ✅
Multi-Runtime ✅ ✅ ❌ ❌

Realm combines the best aspects of these tools into a cohesive development environment.

Getting Started

Ready to simplify your development workflow?

  1. Install Realm: cargo install realmenv
  2. Initialize a project: realm init
  3. Start developing: realm start

Check out the GitHub repository for documentation, examples, and to contribute.

Conclusion

Modern full-stack development doesn't have to be complex. With Realm, you get:

  • One command to start your entire stack
  • Automatic routing without proxy configuration
  • Runtime isolation without global pollution
  • Templates to eliminate boilerplate
  • Deployment generation without Docker expertise

If you've ever felt frustrated managing multiple terminals, runtime versions, or proxy configurations, give Realm a try. It might just change how you approach development environments.

Have you tried Realm? What's your biggest pain point in full-stack development? Let me know in the comments!

Links:

Top comments (0)