Documents

Overview

Coalstack is a desktop app for running and managing your own Minecraft server. It runs on Windows, with an experimental Linux build (see the Linux notes), and handles everything from downloading the server software to keeping backups, all from one window on your own computer. You don't need a hosting provider, a VPS, or any command-line experience.

The app is built with Tauri (Rust) and React. The server process runs on your machine. Coalstack picks the Java version your server needs and downloads it from Adoptium (Eclipse Temurin) the first time. Each version is stored once in the app's data folder and shared by every server that needs it. If that download fails, Coalstack falls back to whatever Java is already on your PATH. Your world files, server configuration, and console output never leave your computer.

Coalstack talks to our servers at coalstack.net only for account and license verification, update checks, and optional features you explicitly turn on (remote admin commands via the website, Discord webhook notifications). It never reads or uploads your world data.

Getting Started

Download the installer from the Download page and run it. Coalstack installs like any other Windows app.

The first time you open the app, Coalstack takes you straight into the New Server flow. After that, it remembers your last-used server and opens directly to it; if that folder is missing, you land on the All Servers page instead. From there you have two ways to add a server:

• Add a server I already have: point Coalstack at a folder that already contains a Minecraft server (a server.jar file, an accepted EULA, and the usual server directory layout). Coalstack will detect its platform and version automatically and pick up right where you left off.
• Create a new server: the Setup Wizard walks you through picking a platform (Vanilla, Paper, Fabric, Forge, or NeoForge), a Minecraft version, a name, and where the server files go. Coalstack downloads the correct server jar, creates the folder, accepts the EULA on your behalf, and writes an initial server.properties file. The server is ready to start immediately afterward.

You can add as many servers as you want. Each one is an independent folder on disk with its own world, configuration, mods, and settings. Switch between them from the server switcher in the title bar (click the server name and status pill next to the Start/Stop button), or from the All Servers page.

All Servers

All Servers shows every server you've added as a card. It's a normal sidebar item, not the home screen anymore - Coalstack opens straight to your last-used server (see Getting Started) and lands here only if that folder can't be found. Each card displays:

• The server's name, platform icon, and Minecraft version
• A status pill: RUNNING, OFFLINE, BOOTING UP, STOPPING, or RESTARTING
• The folder path on disk
• Copyable IP address and domain address (if one is configured)
• Live CPU percentage, RAM usage, and player count while running
• Start/Stop, Clone, and Dashboard buttons - Dashboard opens the Server workspace for that server
• A "Show more details" button that expands to reveal the world name, size on disk, seed, dimensions present, and a count of installed mods and plugins
• A red warning icon if any errors or crashes were logged for that server this session

Below the cards, the Global Performance section shows the combined CPU and RAM usage across all currently running servers. This is useful when you're running several servers at once and want to see the total load at a glance.

The "New Server" card at the end of the grid opens a dialog to either point at an existing server folder or launch the Setup Wizard for a fresh one.

Server Workspace

Selecting a server takes you to the Server page - the main control surface, split into two tabs: Overview and Console. Everything on it updates live. The title bar above every page also carries the server switcher and the Start/Stop button, so the running server can be controlled from any page, not just this one.

Switching Servers

Click the server name and status pill in the title bar to open a dropdown listing every server for the current game, each with its running state, plus "＋ New server" and "All servers". This is the one place to switch servers now - it replaces the old fleet strip and the per-page switchers that used to live on the Dashboard.

Overview Tab

A status strip across the top shows the platform icon, name, version (editable if unknown), status pill, session uptime, port (editable inline - changing it cascades to UPnP and firewall rules the same way it always has), and a copyable connect address. If the server is running but not port-forwarded, a line appears linking straight to Networking.

Below that, three compact cards sit side by side: CPU and Memory, each with a sparkline of the last 30 samples (one every 2 seconds) so you can see trends rather than just the current number, and Players, showing everyone online with their Minecraft head icon pulled from mc-heads.net (a colored initial circle if the head service is unreachable). A Health card appears while the server is running; threshold editing is a PRO feature.

Quick Settings

A card lets you change difficulty, gamemode, PvP, and hardcore mode with simple dropdowns and checkboxes. Changes are written to server.properties immediately but take effect the next time the server starts - a note to that effect stays visible under the controls instead of fading out after a few seconds.

Console Tab

A Console | Chat toggle at the top switches between the raw live console and a structured chat view. The console streams the server's live output with every line color-coded (errors red, warnings yellow), a search filter box, and a "Clear" button that empties the visible buffer without touching the log file on disk. The Chat view extracts every INFO-level line into player chat messages, joins/leaves, deaths, advancements, and announcements, searchable by player name or message content. Both views respect the "Hide RCON Client messages" setting in the app's Settings page, since Coalstack's own RCON traffic (automations, scheduled commands, the send-command bar) would otherwise clutter both.

For servers that produce huge amounts of log output during boot (heavily modded Forge or NeoForge instances can dump thousands of lines), there's a "Virtualize the console" setting in the app's Settings page. When enabled, only the visible rows are mounted in the DOM, which keeps the interface responsive during startup. The tradeoff is that native browser text selection and Ctrl+F search across the whole log won't work in virtualized mode, so it's off by default.

A send-command bar sits directly beneath the console, working the same way as before: commands starting with / are sent as-is (like /weather clear); text without a leading slash is sent as a chat message (like Server restarting in 5 minutes). The input keeps a command history you can recall with the up and down arrow keys, and a "Help" button opens the Minecraft wiki's commands reference. Any macros you've saved live under a "Saved commands ▾" disclosure in this same tab.

Server Creation & Cloning

Setup Wizard

The Setup Wizard walks through picking a platform (Vanilla, Paper, Fabric, Forge, or NeoForge - each with a one-line plain-English description of what it means), a Minecraft version fetched live from that platform's own API, a name, and where the server files go. That location is pre-filled to Documents/Coalstack/Servers/<name>, so you never have to open a folder picker unless you want to. RAM is set automatically to a safe share of your system's total and sits behind a "Change" disclosure if you'd rather set it yourself.

Coalstack fetches the correct server jar, creates the folder structure, accepts the Minecraft EULA on your behalf, and writes a starting server.properties. The wizard runs full-width now instead of a narrow centered column, and it handles platform-specific installers like the Forge and NeoForge bootstrap jars automatically.

Cloning

The Clone button on each server card creates a copy of that server in a new folder. You choose a name and parent folder, then pick between a full clone (copies the world too) or a template clone (same server software and settings but a fresh world). The original server must be stopped first, since copying a live world mid-write would risk corruption. The clone lands on the Servers page and is ready to start immediately.

Modpack Installation

Beyond the Setup Wizard, you can also create a server by installing a modpack directly from Modrinth. The Marketplace page has a "Modpacks" search that lists Modrinth modpacks with their game versions and loaders. Picking a pack version downloads the .mrpack file and installs it as a complete, ready-to-run server.

Content: Mods & Plugins

Mods, plugins, resource packs, and data packs all live under the Content page's Mods & Plugins tab (people still call the interface itself "the Marketplace"). It's built around four sub-tabs: Mods, Plugins, Resource Packs, and Data Packs. Each combines a Modrinth-powered search and install interface with a file manager for the corresponding server subdirectory. A fifth sub-tab, Configs, gives you quick access to plugin configuration files.

Browsing and Installing

Each tab's browser section lets you search Modrinth by keyword or browse trending projects. Every result shows the project's title, description, icon, download count, category tags, and compatible game versions. Clicking a result opens a detail panel with the full description, a screenshot gallery, a list of required dependencies (with an "Install required dependencies" button), and a version picker that lists every published version with its game version, loader, filename, and file size.

Installing a project downloads its jar into the correct subdirectory. For mods, the app also checks compatibility with the server's detected platform and version, flagging mods as compatible, incompatible, or unknown - free on every tier.

File Manager

Below the browser, a file manager lists every file in the tab's subdirectory. You can drag and drop files from your desktop to add them, delete files one at a time, rename files, and extract zip archives directly into the folder. The file manager shows each file's name, size, and modification time.

Configs Tab

The Configs tab walks the plugins directory recursively for common configuration file extensions (.yml, .yaml, .json, .toml, .properties, .xml, .conf, .cfg, .hocon) and lists them all in a flat, searchable list. Clicking "Edit" on any file opens an inline text editor where you can modify the config and save it back to disk. This is a quick way to tweak a plugin's settings without leaving the app or digging through nested folders.

Mod Compatibility

The Marketplace's Mods tab shows a compatibility column next to each installed jar, free on every tier. The check reads each mod's internal metadata (mcmod.info, mods.toml, fabric.mod.json) and compares the declared game versions and loader against what the server actually runs. Results are color-coded: compatible (green), incompatible (red with an explanation), or unknown (grey, for mods Coalstack couldn't parse). Compatibility can also be checked across the entire mods folder at once with the "Check Compatibility" button.

World & Files: Files

The Files tab, under World & Files, is for everything that doesn't fit into the dedicated Mods, Plugins, Data Packs, or Resource Packs sub-tabs. It lets you create arbitrary folders at the server root and then manage files inside them with the same drag-and-drop file manager used throughout Content.

This is useful for mods that need their own directory at the server root (a config folder, a scripts folder, a world-gen data folder). You create the folder once, select it from the dropdown, and then add, rename, or delete files inside it.

World & Files: Appearance

Appearance, a PRO-tier tab under World & Files, covers the visual identity of your server. You can set a server icon by picking a 64x64 PNG from your computer; Coalstack copies it to the server-icon.png file that Minecraft looks for at the server root. The page shows a live preview of the current icon.

The MOTD (Message of the Day) editor lets you write the text players see in their server list, with a live preview that shows roughly how it will appear in the Minecraft client. MOTD formatting codes using the section sign are supported. Changes are saved to server.properties and take effect the next time the server starts.

You can also rename the server folder from this page (the display name shown throughout the app is the folder name).

Players: Online

The Online tab, on the Players page, tracks every player who has joined the currently selected server during this session. Each player row shows their Minecraft head icon, their name, the time they joined, how long their current session has lasted, and a running total of their playtime across all sessions this session.

Session tracking is driven by the same log-tailing poll that powers the console and notifications. When a player joins or leaves, the app matches the log line against known join and leave patterns, records the timestamp, and updates the running totals. This data is session-scoped: closing Coalstack resets the counters, since persistent playtime tracking across app restarts would need a database rather than in-memory state.

Player heads are fetched from mc-heads.net. If the service is unreachable, each player shows a colored circle with their initial instead.

Players: Whitelist & Bans

The Whitelist & Bans tab, on the Players page, gives you a visual interface for the three JSON files Minecraft uses to control who can join and who has admin powers. Instead of editing whitelist.json, banned-players.json, and ops.json by hand, you add and remove entries through the app.

Whitelist

Add players by UUID and name. Toggling the whitelist on or off requires editing server.properties (the "white-list" property on the Server Properties page), but Coalstack shows you the current state so you can see at a glance who's on it.

Bans

Ban a player permanently by UUID and name with an optional reason. The ban is written to banned-players.json and takes effect immediately. Coalstack also supports temporary bans: set a duration, and the app will automatically issue a /pardon command when the time is up. Temp bans are checked on the same 15-minute scheduler tick as scheduled commands. Vanilla Minecraft itself has no concept of temp bans; Coalstack tracks the expiry on its own and sends the pardon when it's due.

Operators

Add and remove ops with a permission level (1 through 4, matching Minecraft's own op levels) and a toggle for whether the op bypasses the player limit. Changes are written to ops.json.

World & Files: Settings

The Settings tab, under World & Files, opens with a plain-language "Common settings" section - difficulty, gamemode, max players, PvP, whitelist, online mode, and the server description - for the properties people actually change most. The full key-value table for every other property in server.properties sits below it behind a disclosure.

In that raw table, each row shows the property name on the left and its current value on the right. Editing a value and clicking Save writes the change back to the file immediately. New properties can be added with the input at the bottom.

Changes to most properties only take effect the next time the server starts. A few, like the whitelist and ban list, are read by the server process continuously, but the safe rule of thumb is to restart after making changes here.

Editing server.properties through this page rather than opening the file in Notepad avoids common pitfalls: the app preserves the existing order of properties, keeps comments and blank lines intact, and handles the escaping of special characters correctly.

Server: Performance

Performance, under the Server page's More ▾ menu, shows the server's CPU and memory history over time. Two sparkline charts are stacked vertically: CPU percentage and memory usage in MB, each spanning the last 30 samples collected at 2-second intervals. The current value is displayed as a large number above each chart.

The page also shows your system's hardware specs: the CPU model name, total installed RAM, and RAM type (DDR4, DDR5, etc.) when detectable. This is useful context when deciding how much RAM to allocate.

Performance Presets & Docker

Below the metrics, JVM tuning (renamed "Performance Presets" in the app) and Docker / Container Mode both live on this page now - Container Mode moved here from the Server Overview tab, since it's a one-time-per-server setting rather than something you check daily. Both stay MAX-tier, unchanged from how they've always worked; see Docker Support below.

TPS (Ticks Per Second)

On Paper, Spigot, Purpur, Forge, and NeoForge servers, Coalstack queries the server's TPS via RCON commands (/tps or /forge tps) and includes it in the metrics history. TPS is the best single indicator of server performance: 20.0 means the server is keeping up perfectly, and anything consistently below 18 indicates lag. Vanilla and Fabric servers don't expose TPS through RCON, so the metric isn't available for those platforms.

Backups & Snapshots

Automatic Backups

Coalstack can back up your server automatically on a schedule. You set the interval in hours, and the app zips every world dimension folder (world, world_nether, world_the_end, or whatever your level-name is set to) into a timestamped archive in the server's backups directory. Backups only run while the server is running, since that's when the world files are changing. The backup scheduler checks every 15 minutes whether any server is due.

Manual Backups & Snapshots

You can trigger a backup manually at any time from the Backups page with the "Back Up Now" button. A snapshot is the same thing as a backup but stored in a separate snapshots directory and limited to the 5 most recent; it's meant for quick save points before trying something risky rather than long-term archival.

Restoring

From the Backups page you can restore any backup or snapshot. Restoration deletes the current world folders and extracts the archive in their place. The server must be stopped first. Each backup entry shows its filename, size, and creation date so you can find the right one.

Secondary Destination

You can set a secondary backup directory: an external drive, a NAS mount, or a synced cloud folder like OneDrive or Google Drive on disk. Every time a backup is created, Coalstack copies it to this second location too. If the secondary destination is unavailable (drive unplugged, network share down), the primary backup still succeeds and the app logs a warning rather than failing the whole operation.

Pruning

You can set a maximum number of backups to keep. When a new backup is created, Coalstack deletes the oldest ones beyond that limit. Set it to 0 or leave it blank for unlimited backups.

Networking

The Networking page is where you make your server reachable from the internet, across two tabs: Port Forwarding (core) and Custom Domain (More ▾). Between them they cover four approaches, from simplest to most advanced.

Port Forwarding with UPnP

UPnP (Universal Plug and Play) lets Coalstack ask your router to forward a port automatically. You pick a port number and protocol (TCP, UDP, or both), and the app discovers your router via SSDP, adds a port mapping, and optionally creates a Windows Firewall rule if you're running as administrator. The status line shows whether the mapping is active. The firewall rule step is Windows only; on Linux you open the port in your own firewall.

Not all routers support UPnP, and some have it disabled by default. If discovery fails, you'll need to forward the port manually through your router's admin interface.

Custom Domain

If you already own a domain and have pointed an A record at your public IP, you can enter it here. Coalstack will show yourdomain.com:port as the connect address on server cards instead of a raw IP. The app doesn't manage the DNS for you, it just remembers the domain as a display preference.

Dynamic DNS: DuckDNS

DuckDNS is a free dynamic DNS service. You create a subdomain (likemyserver.duckdns.org) on their website, get a token, and enter both into Coalstack. The app then pings DuckDNS's update API every 5 minutes with your current public IP, keeping the subdomain pointed at your machine even if your residential IP changes when your ISP re-leases it or your router reboots.

Dynamic DNS: Cloudflare

If you own a domain hosted on Cloudflare, Coalstack can update an A record automatically using a Cloudflare API token scoped to Zone:DNS:Edit. You provide the token, root domain (like example.com), and record name (like play.example.com). The app updates Cloudflare's DNS every 5 minutes with your current public IP, just like DuckDNS.

Address Display

On every server card, Coalstack shows the best available connect address: your custom domain if set, otherwise your DuckDNS or Cloudflare domain if active, otherwise your raw public IP. Each address is copyable with one click.

World & Files: Live Map

Live Map, tucked under World & Files' More ▾ menu, shows your world if you're running Dynmap or BlueMap (plugins that render Minecraft as a browsable web map). Coalstack detects them and shows the map in an embedded iframe. The detection checks the server's plugins directory for either plugin and reads the port from their respective configuration files.

If neither plugin is installed, the page shows a link to Content where you can install one. Coalstack doesn't bundle its own map renderer; it relies on these existing plugins, which are mature, well-maintained, and far more capable than anything the app could realistically replicate.

Server: Diagnostics

Diagnostics, under the Server page's More ▾ menu, stacks two tools on one page: the free Auto Debugger at the top, and the paid AI Log Analyzer (see AI Tools) below it. Sharing a page doesn't share a code path - the Auto Debugger stays a deterministic pattern matcher either way.

The Auto Debugger scans the server's latest.log, recent crash report files, and the server's captured console output for known error patterns: OutOfMemoryError, port conflicts, mod dependency issues, corrupted chunk warnings, client-only mods installed on a server, and several dozen others. It filters out benign noise like deprecation notices and informational lines that look alarming but aren't.

This is a fixed, deterministic pattern matcher written in Rust, not an AI call. It's available on the free tier because it doesn't cost anything to run. Each match is shown with the file it came from, a stable error code, a plain-English explanation of what the error means, and the surrounding log lines for context. See the full error code reference for longer explanations than fit in the app.

Notifications

A 🔔 icon in the title bar opens a popover with the same feed; "See all" opens the full Notifications page below, which shows a real-time feed of events for the currently selected server. Each entry has a timestamp, the server name, and a message. Events are categorized by type with a colored icon:

• Join (green): a player connected
• Leave (grey): a player disconnected
• Advancement (amber): a player earned an achievement
• Restart (grey): the server restarted
• Error (red): an error was logged
• Crash (red): the server stopped unexpectedly
• Automation (green): an automation rule fired and this was its result

You can filter by type using the tab bar, or clear all notifications for the current server. Notifications are session-scoped; they clear when Coalstack closes. The feed is driven by the same central log-tailing poll in App.tsx that streams console output, so notifications appear regardless of which page you're on.

The Settings card on this page includes a toggle to permanently hide the "Hey! I see you are using our app" feedback toast that appears on startup. When checked, the toast won't appear on any future launch. The setting persists in localStorage.

Automations

Automations, under the Server page's More ▾ menu, are visual IF/THEN rules. You pick a trigger and one or more actions, and Coalstack runs them automatically when the trigger fires. Rules are per-server and stored in that server's coalstack-server-config.json file. Scheduled Restarts and Scheduled Commands (below) are sections of this same page, not a separate screen.

Triggers

• A player joins: fires every time someone connects. Optionally restricted to a player's first-ever join to this server (Coalstack tracks every name it's ever seen join).
• A player leaves: fires every time someone disconnects.
• Server is empty for N minutes: fires once after the server has had zero players online for the specified duration. Resets when someone joins. Useful for stopping an idle server.
• Server crashes: fires when the server stops unexpectedly (the process exits without a deliberate "stop" command).
• Server finishes booting: fires when the server is fully started and ready for connections.
• On a time schedule every N minutes: fires repeatedly at a fixed interval, like a cron job.
• CPU usage exceeds N%: fires when the server process's CPU usage surpasses the threshold. Subject to a 5-minute cooldown to avoid spamming.
• Memory usage exceeds N MB: fires when the server process's memory usage surpasses the threshold. Same 5-minute cooldown.

Actions

• Run console command: sends an arbitrary command to the server via RCON. The command's result is logged to notifications.
• Stop the server: gracefully stops the server.
• Restart the server: gracefully restarts the server.
• Run a backup: creates a backup of the world folders immediately.

Multiple Actions

A single rule can have multiple actions. For example: "IF server crashes THEN run a backup AND restart the server." Actions run in sequence; if one fails (a backup runs out of disk space, say), the rest still execute.

How They Run

Event-based triggers (player join, player leave, server empty, crash, server online) are detected by the frontend's log-tailing poll in App.tsx, which scans every new log line for the matching pattern. Time-based triggers (scheduled, CPU high, memory high) are evaluated by a Rust-side scheduler that runs every 60 seconds. Both paths call the same action dispatch logic. Every execution is logged to Notifications with the command and its result.

Conditions, Cooldowns & Circuit Breaker (MAX)

Any rule can be narrowed with a condition: only fire if the player count is above or below a number, or only during a time window (e.g. no restart pings between midnight and 8am). A cooldown stops a rule from re-firing again for N minutes after it last ran. A circuit breaker auto-pauses a rule (with a notification) if it fires more than a set number of times in an hour - a safety net for crash-triggered rules that could otherwise loop if something's actually broken.

Scheduled Commands & Restarts

In addition to the full rule-based system above, the Automations page has two simpler built-in schedulers for the most common use cases.

Scheduled Restarts

Turn on automatic restarts with a configurable interval in hours. Coalstack checks every 15 minutes whether a restart is due and issues a graceful restart if the server is running. The last restart time is displayed. This is a MAX-tier feature.

Scheduled Commands

Add any number of console commands that repeat on their own interval. For example,save-all every hour, or a broadcast every 30 minutes to warn players about an upcoming restart. Each command has its own independent interval, enabled toggle, and last-run timestamp. Checked on the same 15-minute scheduler tick as restarts and temp bans. This is a MAX-tier feature.

Webhook Notifications

Coalstack can send notifications to Discord, Slack, or any endpoint that accepts a JSON webhook POST. The webhook is per-server: paste the URL into the Settings page's Webhook Notifications section, pick the matching format (Discord/Slack/Generic), and Coalstack posts messages there automatically. This is a PRO-tier feature.

The app sends notifications for: the server coming online ("Server is online"), a player joining or leaving, and the server stopping unexpectedly (possible crash). A "Send Test Message" button confirms the webhook is working. Webhook URLs are stored in the server's config file; they're not high-value secrets (they can only post messages to one channel), so they don't go through the OS keystore.

Docker Support

With a MAX license, you can run a server inside a Docker container instead of as a plain Java process. Coalstack uses your existing Docker Desktop installation; it never bundles or installs Docker itself.

When Docker mode is enabled for a server, starting it launches an Eclipse Temurin container with the server jar, the world folder bind-mounted, and the game port and RCON port published through to the host. The container is named from the server's folder path, so stop and restart always hit the same container.

Console streaming, RCON commands, and stats monitoring all behave exactly like a plain Java process. Docker mode is scoped to plain -jar launches (Vanilla, Paper, Spigot, Fabric); Forge and NeoForge servers, which use a different launch style involving argument files, aren't supported for Docker yet.

AI Tools

Coalstack ships three AI-powered tools, all built on the Anthropic API (or OpenRouter as an alternative provider). Each requires you to bring your own API key; Coalstack doesn't bundle or proxy any AI calls through its own servers.

Log Analyzer

Paste a server log or crash report into the text box, and Coalstack sends it to the AI with a prompt asking for a plain-English explanation of what went wrong and how to fix it. The result is rendered as Markdown. This is a MAX-tier feature - the free Auto Debugger above covers the same ground with a deterministic pattern matcher instead.

Config Generator

Describe the server settings you want in plain English (for example, "a hard mode survival server with PvP off, a 10,000 block world border, and no nether"), and the AI generates a matching server.properties file. You can review it before saving. This is a paid-tier feature.

Plugin Generator

Describe a plugin you want (for example, "a plugin that gives every new player a stone pickaxe and 16 torches when they first join"), and the AI generates a starter Java class for Paper/Spigot along with a plugin.yml snippet. The generated code is a starting point, not a finished plugin. This is a paid-tier feature.

API Key & Provider

Enter your Anthropic API key in Settings. The key is stored in the Windows credential store (the OS keychain), not in a plain text file. You can switch to OpenRouter as the provider and bring your own OpenRouter key, which gives you access to models from OpenAI, Google, Meta, and DeepSeek in addition to Anthropic's models.

Server Context

When generating configs or plugins, you can optionally include your server's context: the app scans the server jar and its plugins directory for known API classes and sends a summary to the AI so the generated code references the right Minecraft and plugin APIs. You can trigger a rescan from the Settings page.

Players: Roles & Admins

Server Admins

Roles & Admins, under the Players page's More ▾ menu, lets you invite other people to help manage a server without giving them access to your computer or your Coalstack account. You invite someone by email, and they get an email with a link to accept. Each admin gets a configurable set of permissions:

• Can use the console (send commands)
• Can restart the server
• Can manage backups
• Can manage files
• Can manage the whitelist

Admins manage the server through the coalstack.net website, not through the desktop app. Their actions are relayed to your app via a polling mechanism (the Command Relay scheduler, which checks for pending commands every 10 seconds). This same tab's admin log records every admin action with a timestamp and the admin's email - it used to be a separate page, now it's just the bottom of Roles & Admins.

Local API

Coalstack runs a small local HTTP API server on 127.0.0.1 with a randomly generated API key. This is used internally by the command relay and the website's server management features. You can view and regenerate the API key from the Settings page. The API only listens on localhost, so it's never reachable from outside your machine.

Security

Account Security

Your Coalstack account password is hashed with bcrypt by Supabase Auth before it's ever stored. Coalstack itself never sees or saves the plain text. Every connection to coalstack.net is HTTPS, encrypted end to end by Vercel.

API Keys

Your Anthropic and OpenRouter API keys, your login token, and your license key are stored in the Windows Credential Manager, the same secure store Windows uses for saved Wi-Fi passwords and web credentials. On Linux they go in the kernel keyring instead. They're never written to disk as plain text. (See the Linux notes for a caveat about the keyring after a reboot.)

RCON

Coalstack communicates with your server over RCON (Remote Console), a small locked-down connection built into Minecraft for this exact purpose. The RCON password is randomly generated per server and stored in the server's config file. RCON is only bound to 127.0.0.1, so it's never exposed to the internet. You can rotate the password from the Security page if you think someone else got hold of it.

File System Safety

Every file operation that takes a user-supplied path (reading server files, writing configs, extracting zips) validates that the path doesn't escape the server folder. The Rust backend rejects absolute paths, paths containing .. components, and paths with a root prefix. This applies to mod installs from Modrinth too, since anyone can publish a mod or modpack with arbitrary file paths in its manifest.

Settings & Licensing

App Settings

The Settings page covers API key management, AI provider selection (Anthropic or OpenRouter), and console display preferences (virtualize mode for large logs, hide RCON messages).

Licensing

Coalstack uses a bring-your-own-key model for AI features and a tiered license for everything else. The free tier includes server management, console streaming, manual backups, the Marketplace with mod compatibility checks, the Auto Debugger, and the Log Analyzer. Paid tiers (PRO and MAX) unlock automated backups and restarts, config and plugin generation, scheduled commands, automations beyond the free limit, Docker support, and server admin invitations.

You can log in through the app with email and password, or through the coalstack.net website in your browser. The website login supports Google OAuth, which an embedded webview can't handle. When you log in on the website, it sends your license key back to the desktop app via a coalstack:// deep link, so the license applies automatically without a manual copy and paste.

The license is validated against the server on launch and roughly every 24 hours thereafter. If validation fails (you're offline or the server is unreachable), the app falls back to the last known good result within a grace period, so a temporary internet outage doesn't immediately lock you out of paid features.

Updates

Coalstack checks for updates once per launch via the Tauri updater plugin. If an update is available, an UpdateToast appears at the bottom of the window with release notes and a download button. The update is downloaded and applied through Tauri's built-in update mechanism; you don't need to re-run the installer manually.

Tray Icon & Background Operation

Coalstack can keep running in the background after you close the window. The system tray icon (in the Windows taskbar notification area) gives you a menu with "Show Coalstack" and "Quit." Left-clicking the tray icon restores the window.

When you close the window while a server is running, the window hides to the tray instead of quitting. The server keeps running. When you try to quit the app entirely (via the tray menu's Quit or Alt+F4 on the main window), Coalstack shows a confirmation dialog and, if you confirm, gracefully stops every running server before exiting. There's an 8-second timeout on the stop-all step so that a stuck Java process can't prevent the app from closing.

Privacy & Your Data

Your server's files, world data, console output, and configuration stay on your own computer. Coalstack does not read, upload, or analyze your world files. The app talks to coalstack.net only for:

• Account creation, login, and license verification (Supabase Auth)
• License tier checks and feature gating
• Update checks (Tauri updater plugin)
• Remote admin commands (only if you've invited server admins through the website)
• Modrinth API calls for the Marketplace (proxied through the app, not our servers)
• Anthropic or OpenRouter API calls for AI features (direct from the app)

See our Privacy Policy for the full details. If you have questions, contact [email protected].