Mineger

A Minecraft server manager for Windows: create, run and administer your servers from a single app — no command line required.

Mineger is a desktop application built with Tauri: a Rust backend and an HTML/JS interface styled with Tailwind CSS. No account, no mandatory external service — your servers stay as folders on your own disk.

Leggi questo file in italiano · Website: zed2101.github.io/Mineger

---

What it does

Create servers

• Vanilla — the official Mojang server, downloaded and verified against its SHA1.
• Plugins (Paper) — the optimised server that runs Bukkit/Spigot plugins.
• Modded — NeoForge, Forge or Fabric, installed with the official installers.

Minecraft versions and loader builds come from the official sources (Mojang, PaperMC, Forge, NeoForge, Fabric), with the recommended build preselected.

Install from a link

Paste a modpack link and Mineger sets the server up for you:

• CurseForge — official server packs; when a modpack doesn't publish one, the server is built from the client pack (client-only mods left out).
• Modrinth — .mrpack files.
• FTB — modpacks from the Feed The Beast launcher.

When a new version of the modpack is released the app tells you and installs it in one click, backing up the world first and keeping your data (world, configs, backups).

Mods and plugins

• Search and install directly from Modrinth and CurseForge, filtered by your server's Minecraft version and mod loader.
• Every installed file shows where it came from (Modrinth, CurseForge or manual) along with its version.
• An update button appears on mods that have a newer build available.
• Enable and disable files without deleting them (.jar ⇄ .jar.disabled).
• "What your friends must install": the list of mods players need on their side (loader and Minecraft version included), to copy or save as .txt; client-only mods are flagged in the list and can be disabled in one go.
• Mod links pasted where a modpack is expected (and vice versa) are recognised and redirected to the right place; CurseForge/Modrinth rate limits are waited out with visible retries; a modpack update backs up the world first, says what it keeps and what it replaces, and can be undone with one click.

Day-to-day management

• Start and stop with live status, a console with colour-coded logs, and command input.
• CPU/RAM usage of the Java process, disk space, uptime.
• A server.properties editor with plain-language descriptions.
• World backups as zip archives (using save-off/save-all for a consistent copy), with retention (keep the last N and/or N days), backup at every stop, and restore from the app (preview, confirmation, safety backup first).
• The server looks after itself: automatic restart after a crash (growing waits, attempts within a window), schedules (start, stop, restart, backup, command; daily, weekly or every N minutes, with a chat warning before stops), and outgoing Discord notifications through a channel webhook (start, stop, crash, backup failed, join/leave…).
• Server icon (server-icon.png) resized to 64×64 automatically.
• Drag & drop reordering, customisable icons.
• World map rendered from the region files: works for every server kind and version, with the server off too. Modded dimensions and modded block colours included. Players are markers on the map; click one to teleport, view the inventory, send an on-screen message, play a sound, apply an effect and more.
• UPnP port mapping on startup, switchable per server.
• Automatic detection of installed Java runtimes, including those shipped with the Minecraft launcher.
• "Can your friends get in?" — one button tests from outside your network whether the server port answers on your public IP and tells you, in plain language, what is in the way (server not listening, port not forwarded, CGNAT / double NAT, Windows Firewall, wrong target) and how to fix it, with the address to share ready to copy and one-click fixes such as allowing Java in the firewall.
• Plain-language startup diagnosis: when a server fails to start or crashes, the Console tab explains what happened and what to do (EULA, port in use, wrong Java, memory, bad JVM options, missing or incompatible mods, client-only mods, corrupt world, disk full, files blocked by Windows, crash reports) and offers the fix as a button: install Java, disable the culprit mod, accept the EULA, set the RAM, open the folder. Automatic restarts pause when a restart cannot help.
• The right Java per version and loader (minimum and maximum: Forge 1.12 wants exactly 8, Forge 1.16 breaks on 17…) and one-click Java install: a Temurin JRE downloaded from Adoptium into Mineger's own folder, no installer, versions side by side.

Remote control and integrations

• Host mode: one Mineger installation can expose its servers over the network, so friends start and manage them from their own copy of the app through an invite link.
• Webhooks per server: let Discord bots, Twitch extensions or any HTTP service send chat messages, run commands from an allowlist, start/stop the server or read its status — each webhook with its own permissions.
• Discord Rich Presence (optional, off by default): your Discord profile shows "Hosting server · 3/20 online" while a server runs. It only talks to the Discord client on the same PC; the server name and the player count can be hidden.

---

Installation

1. Download the installer from the Releases page.
2. Run the latest Mineger_<version>_x64-setup.exe (or the .msi).
3. Launch Mineger.

Requirements

• 64-bit Windows 10/11.
• Java: 8/17/21 depending on the Minecraft version and loader (Mineger detects what you have, tells you which runtime it will use and, when one is missing, installs it with one click from Settings → Java). Recent versions need Java 21, Minecraft 26.1+ needs Java 25.

---

CurseForge API key

Modrinth and FTB work out of the box. CurseForge requires a personal API key: its terms don't allow shipping a shared key inside an application, so everyone uses their own.

It's free:

1. Go to console.curseforge.com and sign in.
2. Generate an API key.
3. In Mineger: Settings → CurseForge key, paste it and save.

Without a key, CurseForge mods and modpacks are unavailable and the app says so wherever it matters; everything else (Modrinth, FTB, vanilla, Paper, loaders) works normally.

---

Getting started

1. + Add server → pick how to create it:
   • Create new — kind (vanilla / plugins / modded), Minecraft version, loader build.
   • Import ZIP — a server you already have.
   • Add from link — a CurseForge / Modrinth / FTB modpack.
   • Connect remote — a server hosted on a friend's PC.
2. On first start Mineger asks you to accept the Minecraft EULA.
3. Under Properties, set the RAM (large modpacks want 6 GB or more) and choose whether to open the port via UPnP.

Servers live in servers/<name> next to the app (in development, inside the project folder).

---

Playing with friends

No port forwarding possible? Open the server's Details tab, link your playit.gg account (free, approval in the browser) and turn the tunnel on in Properties: at the next start the server gets a public address to give to friends, the same every time. Sign in on playit.gg first, then link. Only the Minecraft port goes through playit; the account and its terms are theirs, Mineger just runs their agent with your key and is in no way affiliated with playit.gg.

Three options, simplest first:

1. Same local network — friends connect to the local IP shown on the Details screen.
2. UPnP — if the router allows it, Mineger opens the port on startup and shows your public IP. A conflict error from the router usually means the port is already forwarded manually, which works just as well.
3. Remote host — whoever keeps a PC running enables the host under Settings → Host and shares the invite link; the others paste it into Connect remote and manage the server from afar.

---

Development

npm install
npm run tauri dev

• npm run css:build / css:watch — compile Tailwind (src/app.css → src/tailwind.css).
• npm run tauri build — produce the installers under src-tauri/target/release/bundle/.
• npm run release:build — same, but signed for the in-app updater, plus latest.json (see Releasing).
• npm run playit:build — builds the playit.gg agent (playitd, BSD-2-Clause) from the official source into src-tauri/binaries/; required once before tauri dev or tauri build, since it ships as a sidecar.
• cd src-tauri && cargo test --lib — backend test suite.
• Tests marked #[ignore] hit the network or install real loaders: cargo test --lib -- --ignored.

You'll need Rust and Node.js 18+.

Technical documentation: architecture · host API and webhooks · API reference on the website, one example per endpoint.

---

Releasing

Installed copies update themselves from the latest GitHub release, so a release needs three things: the version bumped in package.json, src-tauri/tauri.conf.json and src-tauri/Cargo.toml; the Unreleased notes of CHANGELOG.md moved under the new version (they become the release notes and the "What's new" dialog); and the signing key. The key is generated once with npx tauri signer generate -w ~/.tauri/mineger.key -p <password>, with the password saved next to it in ~/.tauri/mineger.key.password: its public half is plugins.updater.pubkey in src-tauri/tauri.conf.json, the private half and the password never enter the repository. Losing them means shipped apps can no longer update themselves, so back up the whole ~/.tauri folder.

npm run release:build builds the installers, signs them and writes src-tauri/target/release/bundle/latest.json, then prints the gh release create command: the NSIS installer, the MSI and latest.json must all be attached to the release.

Translating Mineger

The interface ships in English — American or British spelling — and Italian. On first run Mineger follows your operating system’s language and falls back to English when the system language isn’t available. A US system gets English (US), other English locales get English (UK). You can override it in Settings → Language — the change is immediate and the choice is remembered from then on. Next to each language you’ll see how complete its translation is.

Every string in the app lives in src/language/<code>.json. That one file is read by both the interface and the Rust backend, so translating it covers the whole app — screens, buttons and error messages alike.

Adding a language

1. Create the file from the template

npm run lang:new -- fr

This writes src/language/fr.json containing every key with an empty value, and prints the remaining steps. Use the ISO 639-1 code (fr, de, es, pt-BR…).

2. Translate the values, not the keys

{
  "ui": {
    "topbar": {
      "start": "Démarrer le serveur"   // ← translate this
    }
  },
  "errors": {
    "folder_exists": "Un serveur existe déjà dans le dossier « {id} »"
  }
}

Two rules:

• Keys never change — they're how the app finds the text.
• Placeholders like {id}, {count}, {name} must stay, spelled exactly the same. They're replaced at runtime with real values; the surrounding words can move freely to fit your grammar.
• Some entries have one / other sub-keys for singular and plural — fill in both.
• Product names (Minecraft, CurseForge, Modrinth, FTB, Paper, NeoForge, Forge, Fabric, Java, UPnP) stay as they are.

You don't have to finish in one go: untranslated keys fall back to Italian, and Settings shows the completion percentage.

3. Register the language in two places

src/modules/i18n.js — add an entry to LANGUAGES:

export const LANGUAGES = [
  { code: 'it', name: 'Italiano', english: 'Italian', flag: '🇮🇹' },
  { code: 'en', name: 'English',  english: 'English', flag: '🇬🇧' },
  { code: 'fr', name: 'Français', english: 'French',  flag: '🇫🇷' },   // ← new
];

src-tauri/src/i18n.rs — add the constant and the entry in available():

const FR: &str = include_str!("../../src/language/fr.json");   // ← new

pub fn available() -> Vec<(&'static str, &'static str)> {
    vec![("it", "Italiano"), ("en", "English"), ("fr", "Français")]  // ← new
}

…and add it to the dictionary cache in the same file, next to the existing m.insert("en", flatten(EN));:

m.insert("fr", flatten(FR));

4. Check your work

cd src-tauri && cargo test --lib i18n

These tests fail if a language is missing keys or if a {placeholder} doesn't match the Italian original — so a half-finished translation shows up as a test failure instead of stray text in the app. Then run npm run tauri dev, open Settings → Language and pick your language: everything should switch instantly.

When the app gains new strings

Run npm run lang:template to refresh src/language/_template.json, then add the new keys to each language file. cargo test --lib i18n lists exactly which keys are missing.

---

Contributing

Bug reports and feature requests go through the issue templates; code, docs and translations through pull requests, see CONTRIBUTING.md. Security problems have a private channel, described in SECURITY.md.

Licence

MIT — see LICENSE.

Mineger is not affiliated with Mojang, Microsoft, Overwolf/CurseForge, Modrinth or Feed The Beast. Minecraft is a trademark of Mojang AB.