Cubelit

Self-host game servers with ease.

A modern desktop app that lets you create, manage, and monitor game servers through Docker — no command line needed.

---

About

Cubelit turns Docker containers into one-click game servers. Pick a game, tweak the settings, and hit create — Cubelit handles the image pull, container configuration, port mapping, and volume management behind the scenes.

Built with a Rust backend for performance and reliability, and a Svelte 5 frontend for a snappy UI.

Key Features

• One-click server creation — Choose a game, configure settings through a visual wizard, and your server is live
• 11 supported games out of the box, with a recipe system designed for easy expansion
• Full lifecycle management — Start, stop, restart, and delete servers from the dashboard
• Real-time progress — Watch image pulls and server creation in real time via streamed events
• Live resource stats — CPU and memory usage cards on every server dashboard, auto-polled while the server is running
• Settings editing — Edit environment variables and apply changes; Cubelit recreates the container automatically
• Mod & plugin management — Upload, drag-and-drop, and delete .jar files directly from the dashboard (Minecraft)
• Backup system — One-click server backup via the Console tab (Minecraft)
• Minecraft console — Send RCON commands, quick-action buttons (OP self, whitelist, save, weather), and command history
• Connection info — Local and public IP addresses shown on the overview, so you can share the address with friends
• Open folder buttons — Jump straight to server files, mods, or plugins in your file manager
• Automatic state sync — On startup, Cubelit inspects Docker to sync server statuses with reality
• Port management — Built-in port availability checking with auto-suggestions
• Persistent data — Each server gets its own volume directory that survives restarts and upgrades
• Dark/light theme — Theme toggle persisted to localStorage; clean purpose-built Console design

Supported Games

All 11 games ship as ready-to-use recipes in v0.2.0.

Game	Docker Image	Mods	Status
Minecraft Java	itzg/minecraft-server	Yes	Available
FiveM	spritsail/fivem	Yes	Available
Minecraft Bedrock	itzg/minecraft-bedrock-server	--	Available
ARK: Survival Evolved	hermsi/ark-server	Yes	Available
ARK: Survival Ascended	johnnyknighten/ark-sa-server	Yes	Available
Counter-Strike 2	joedwards32/cs2	--	Available
Palworld	thijsvanloef/palworld-server-docker	--	Available
Project Zomboid	indifferentbroccoli/projectzomboid-server-docker	Yes	Available
Rust	didstopia/rust-server	Yes	Available
Terraria	ryshe/terraria	Yes	Available
Valheim	lloesche/valheim-server	Yes	Available

Each game is defined as a JSON recipe in src-tauri/recipes/. Adding a new game is as simple as creating a new recipe file — no code changes required.

Tech Stack

Layer	Technology
Desktop framework	Tauri v2
Frontend	SvelteKit 5 + TypeScript
Styling	Tailwind CSS v4
Backend	Rust
Docker client	Bollard
Database	SQLite via sqlx
Package manager	Bun

Prerequisites

• Rust (latest stable)
• Bun (v1.0+)
• Docker Desktop (must be running)
• Platform-specific Tauri dependencies:
  • Windows: Microsoft C++ Build Tools, WebView2 (included in Windows 10/11)
  • macOS: Xcode Command Line Tools
  • Linux: See Tauri prerequisites

Getting Started

1. Clone the repository

git clone https://github.com/UnHeardCoder/Cubelit.git
cd cubelit

2. Install dependencies

bun install

3. Run in development mode

bun run tauri dev

This starts both the Vite dev server (frontend hot reload) and the Rust backend. The app window will open automatically.

4. Build for production

bun run tauri build

Produces platform-specific installers in src-tauri/target/release/bundle/.

Development

Useful commands

# Type-check the frontend
bun run check

# Type-check the Rust backend (fast, no full build)
SQLX_OFFLINE=true cargo check --workspace --all-targets

# Lint Rust code
SQLX_OFFLINE=true cargo clippy --workspace --all-targets

# Run the frontend Vite server standalone (without Tauri)
bun run dev

Project Structure

src/                          # Frontend (SvelteKit)
  routes/
    +layout.svelte            # App shell — sidebar, Docker gate
    +page.svelte              # Dashboard
    create/+page.svelte       # Server creation wizard
    server/[id]/+page.svelte  # Server detail & management
  lib/
    api/                      # Tauri IPC wrappers
    stores/                   # Svelte 5 rune-based state
    components/               # Reusable UI components
    games/                    # Game registry + per-game Setup/Dashboard components
    types/                    # TypeScript interfaces

crates/
  core/                       # cubelit-core — all business logic (Docker, DB, recipes, lifecycle)
  cli/                        # cubelit-cli — standalone CLI sharing cubelit-core

src-tauri/                    # Tauri desktop crate — thin IPC transport layer
  src/
    lib.rs                    # App entry — setup, command registration
    state.rs                  # AppState wrapping LocalServerHost
    event_sink.rs             # TauriEventSink (maps CoreEvents → Tauri emit)
    commands/                 # Tauri IPC command shims (3–7 lines each)
  recipes/                    # Game server JSON templates
  tauri.conf.json             # Tauri configuration

Architecture

The frontend communicates with the Rust backend exclusively through Tauri's IPC system:

• Commands (invoke()) — Request/response for CRUD operations and actions
• Events (emit() / listen()) — Streaming updates for long-running operations like image pulls and server creation

All Docker operations, database access, recipe parsing, and port management happen in Rust. The frontend is a pure presentation layer with thin API wrappers and reactive stores.

Adding a New Game

Simple games (standard Docker image, no special setup): only a JSON recipe is needed.

1. Create a JSON file in src-tauri/recipes/ (e.g. my-game.json)
2. Follow the recipe schema:

{
  "id": "my-game",
  "name": "My Game",
  "description": "Short description of the game server.",
  "icon": "my-game",
  "available": true,
  "docker_image": "dockerhub/image-name",
  "default_tag": "1.2.3",
  "ports": [
    { "container_port": 7777, "default_host_port": 7777, "protocol": "tcp", "label": "Game Port" }
  ],
  "environment": [
    { "key": "SERVER_NAME", "default_value": "My Server", "label": "Server Name", "type": "string", "options": [] },
    { "key": "MAX_PLAYERS", "default_value": "16", "label": "Max Players", "type": "number", "options": [] }
    // Supported types: "string", "number", "boolean", "select", "ram"
  ],
  "volumes": [
    { "container_path": "/data", "label": "Server Data" }
  ],
  "config_files": [],
  "mods": null,
  "estimated_disk_mb": 2000,
  "tags": ["survival"]
}

3. Restart the app — your game appears in the creation wizard with the generic setup form.

Complex games (sidecars, special env handling, custom UI): also require Svelte components (*Setup for the create wizard, *Dashboard for the server detail page) and potentially backend changes in src-tauri/src/docker/containers.rs. See the FiveM implementation as a reference.

Troubleshooting

Docker not detected

• Ensure Docker Desktop is running before launching Cubelit
• On Linux: verify the docker daemon is running (systemctl status docker)
• On Windows: Docker Desktop requires WSL2. Cubelit can enable the WSL and Virtual Machine Platform optional features for you.
• You do not need to install Ubuntu or another standalone WSL distro just for Cubelit. Docker Desktop creates and manages its own WSL backend.
• After enabling WSL features, reboot Windows, then install and start Docker Desktop.

Server stuck in "Starting" state

• Check the server logs tab for startup errors
• Some games take several minutes on first launch (image download)
• If stuck indefinitely, try stopping and restarting the server

Port already in use

• Cubelit will suggest an available port automatically
• You can also specify a custom port during server creation

App data location

• Linux: ~/.config/cubelit/
• Windows: %APPDATA%\cubelit\
• macOS: ~/Library/Application Support/cubelit/
• Logs: cubelit.log in the above directory

Roadmap

• Server management tabs — Overview, mods/plugins, settings, console/logs (Minecraft + FiveM)
• Log viewing — Container log viewer with auto-polling while server is running
• Mod & plugin management — Upload, drag-and-drop, and delete .jar files (Minecraft)
• Settings editing — Edit environment variables; container is recreated with new settings on apply
• Live stats — CPU and memory usage cards, auto-polled every 5 seconds while running
• Backup system — One-click backup from the Console tab (Minecraft)
• Minecraft console — RCON command input with history, quick-action buttons
• Connection info — Local + public IP display so friends know what address to use
• Open folder — Jump to server files, mods, or plugins in the OS file manager
• Server updates — One-click Docker image pull + container recreate
• System tray — Background operation with tray icon
• More games — all 11 recipes available (ARK: Survival Evolved, ARK: Survival Ascended, CS2, Minecraft Bedrock, Palworld, Project Zomboid, Rust, Terraria, Valheim added in v0.2.0)

License

MIT