miniVE documentation

Everything from install to uninstall. Five minutes to your first disposable environment.

Requirements

No account. No telemetry. Nothing leaves your machine.

Install

One-liners

macOS, Linux, WSL:

curl -fsSL https://sahilsidhu7.github.io/minive-landing/install.sh | bash

Windows PowerShell:

irm https://sahilsidhu7.github.io/minive-landing/install.ps1 | iex

Windows CMD:

curl -fsSL https://sahilsidhu7.github.io/minive-landing/install.cmd -o install.cmd && install.cmd && del install.cmd

The script picks the right package for your system: Homebrew cask or .dmg on macOS, .deb / .rpm / AppImage on Linux and WSL, .msi on Windows. Prefer doing it by hand? Read on.

Windows

winget install SahilSidhu7.miniVE

Or download the .msi from the latest release and run it.

The installer isn't code-signed yet, so SmartScreen may show "Windows protected your PC". Click More info → Run anyway. One-time step.

macOS

brew install --cask sahilsidhu7/tap/minive

Or download the .dmg from the latest release - aarch64 for Apple Silicon (M-series), x64 for Intel - and drag miniVE to Applications.

The app isn't notarized yet, so the first launch is blocked with "miniVE cannot be opened". Open System Settings → Privacy & Security, scroll down, click Open Anyway, then confirm. One-time step. (Installing via Homebrew handles quarantine for you.)

Linux

From the latest release, either:

# AppImage - portable, no install
chmod +x miniVE_*.AppImage
./miniVE_*.AppImage

# or Debian/Ubuntu package
sudo dpkg -i miniVE_*_amd64.deb

# or Fedora/RHEL package
sudo dnf install ./miniVE-*.x86_64.rpm

Works with Docker Engine directly - Docker Desktop isn't required on Linux, just a running daemon your user can talk to (member of the docker group).

Quick start: first environment in five minutes

  1. Start Docker Desktop. If it isn't running, miniVE shows a gate screen with a re-check button - start Docker, hit Re-check.
  2. Click New Environment. Give it a name and pick a base system - Ubuntu, Debian, Alpine, or Fedora, any available version.
  3. Pick your languages. Tick any combination of Python, Node, Go, Rust, Java, Ruby, PHP - with a version where the installer can honor one (exact for Go/Rust, major for Node/Java; the rest use the distro's package). They're installed on top of the base by a startup script, so one project can mix as many languages as it needs.
  4. (Optional) pick a package preset - Minimal (git + curl), Full (+ vim, unzip, build tools), or Dev essentials, which updates and upgrades the system and installs the tools developers expect: git, curl, wget, ssh client, vim, nano, build toolchain, jq, htop, tree, zip/unzip, rsync, and more.
  5. (Optional) map a port - e.g. container port 8000 to host port 8000 if you'll run a web server.
  6. Create. First use of a runtime pulls its image (progress shown); later environments on the same runtime start in seconds.
  7. Open a terminal tab - you land in /workspace, a persistent volume. Install packages, run code; it all stays inside the environment.

Getting files in

The file tree shows the live contents of /workspace. Files created from the terminal appear there too.

Terminal

Scripts

Every environment has a Scripts panel in the workspace sidebar - small shell scripts stored with the environment:

Add, edit, and delete scripts from the panel; they're plain sh scripts, nothing magic.

Docker inside an environment

A Docker daemon can't run inside an ordinary container - so miniVE doesn't try. Tick Docker CLI when creating an environment and miniVE instead:

docker commands inside the environment then drive your host's Docker daemon ("docker-outside-of-docker"). docker build, docker run, compose-style workflows - they all work.

Containers you start from inside run on the host, next to your other containers - and socket access is root-equivalent on the host. Only enable this for environments running code you trust.

CLI

The minive command manages the same environments as the app - anything created in one shows up in the other. Build it from the repo with cargo build --release --bin minive (in src-tauri/).

minive create py --image python:3.12 --port 8000:8000   # create + start
minive shell py                 # interactive shell in /workspace
minive exec py python app.py    # one-off command (no TTY, pipes work)
minive list                     # all environments
minive stop py / start py / delete py

Multiple terminals, one environment: run minive shell py in as many terminal windows as you like - each gets its own independent shell inside the same environment, so you can run a server in one and edit or test in another.

create defaults to ubuntu:24.04 with the minimal preset (git + curl); pass --preset none|minimal|full|essentials to change it (essentials = update + upgrade + common dev tooling).

Port preview

If you mapped ports at creation, run your server inside the environment and it's reachable at localhost:<host-port>:

python -m http.server 8000
# or
npm run dev -- --host 0.0.0.0

The preview pane renders the page inside miniVE; you can also open it in your regular browser. The preview's address bar is editable - type a path like /api/health (or a full URL) and press Enter.

Servers must bind 0.0.0.0 (not 127.0.0.1) to be reachable from outside the container. Most dev servers have a --host flag for this.

Stop, restart, delete

ActionWhat happens
StopContainer stops; files and installed packages are kept.
StartPicks up exactly where you left off.
DeleteContainer and its /workspace volume are removed. Unrecoverable, and leaves zero trace - docker ps -a and docker volume ls show no minive-* entries.

Everything miniVE creates carries a minive.env Docker label, so you can audit it yourself with plain docker commands.

Updates

miniVE checks GitHub for a newer release on launch. If one exists you'll be asked before anything is downloaded; decline and nothing changes. Updates are cryptographically signed and installed in place. You can always update manually from the releases page.

Troubleshooting

"Docker is not running" gate screen won't go away

Port preview shows nothing / connection refused

Git clone fails

Image pull is slow or fails

Something else? Open an issue - include your OS and Docker Desktop version.

Uninstall

  1. Delete your environments from within miniVE first (removes containers and volumes).
  2. Uninstall the app: Windows - Settings → Apps (or winget uninstall SahilSidhu7.miniVE); macOS - drag from Applications to Trash (or brew uninstall --cask minive); Linux - remove the AppImage or sudo dpkg -r miniVE.
  3. Leftover check (optional): docker ps -a and docker volume ls should show no minive-* entries; runtime images (python, node, ubuntu) are standard Docker images you may keep or docker rmi.

FAQ

Is my code sent anywhere?

No. miniVE talks only to your local Docker daemon. The only network calls the app itself makes are pulling images from Docker Hub and the update check against GitHub.

How is this different from a VM?

Containers share your machine's kernel via Docker, so they start in seconds and cost far less RAM/disk than a VM - while still keeping code, packages, and processes isolated from your host.

Can two environments talk to each other?

Not in v1 - each environment is independent. They can each reach the internet, and you can reach them via mapped ports.

What are the resource limits?

Whatever Docker Desktop is configured to allow (its Settings → Resources). miniVE doesn't impose extra limits in v1.