Docs / Erste Schritte / Intro

Intro

EasyLauncher ist eine modulare Library, die dir den Bau eigener Minecraft-Launcher extrem erleichtert – völlig unabhängig von der genutzten Programmiersprache.

Statt ewig Mojangs JSON-Strukturen zu entschlüsseln oder dich mit dem Microsoft-Login rumzuschlagen, nutzt du einfach unsere API. Da EasyLauncher rein headless läuft, bist du beim Design deiner Oberfläche komplett frei.

Wichtig: Das hier ist eine reine Backend-Library. Du schreibst das Frontend (egal ob React, Swing, Tkinter oder Tauri) und wir übernehmen die komplette Minecraft-Engine im Hintergrund.

Setup

Zieh dir einfach das passende Package über deinen Package-Manager.

npm install easylauncher-node

Quickstart

So startest du Vanilla Minecraft in ein paar Zeilen Python-Code:

from easylauncher import MinecraftLauncher, Version
from easylauncher.auth import OfflineAuth

# Arbeitsverzeichnis festlegen
launcher = MinecraftLauncher(directory="./.minecraft")

# Offline-Account fürs lokale Testen
account = OfflineAuth("Notch")

# Spieldateien ziehen
launcher.install(Version("1.20.4"))

# Game launchen
launcher.launch(
    version="1.20.4",
    auth=account,
    ram_mb=4096
)

Authentifizierung

EasyLauncher bietet Offline-Logins (praktisch für die Entwicklung oder Offline-Server) und die offizielle Microsoft-Authentifizierung via OAuth2.

Security-Hinweis: Speichere niemals Passwörter im Klartext. Wir kümmern uns automatisch um das sichere Caching der Session-Tokens.

Offline Login

Ideal, um lokal schnell Sachen auszuprobieren.

import { OfflineAuth } from 'easylauncher';
const auth = new OfflineAuth('DevPlayer_1');

Microsoft Login

Für echte Accounts stößt du einfach den interaktiven Login-Flow an. Den nervigen Xbox-Live-Handshake regeln wir intern.

import { MicrosoftAuth } from 'easylauncher';

const auth = new MicrosoftAuth({ clientId: 'DEINE_AZURE_CLIENT_ID' });

// Öffnet den Browser, damit der Nutzer sich anmelden kann
const session = await auth.loginInteractive();
console.log(`Eingeloggt als ${session.profile.name}`);

Versionen & Mods

EasyLauncher holt sich das offizielle Version-Manifest von Mojang. So kommst du extrem simpel an die neuesten Releases oder Snapshots ran.

use easylauncher::versions::VersionManifest;

// Hol dir den aktuellsten Release
let manifest = VersionManifest::fetch().await?;
let latest_release = manifest.latest.release;

println!("Neueste Version: {}", latest_release);

Fabric / Forge installieren

Modloader einzubinden ist super easy. Du packst einfach das Modloader-Objekt mit in den Install-Aufruf und fertig.

from easylauncher.modloaders import Fabric

# Lädt Minecraft 1.20.4 herunter UND richtet direkt Fabric ein
launcher.install(Version("1.20.4"), modloader=Fabric(loader_version="0.15.7"))

Downloads

Minecraft zieht Tausende von Assets und Libraries. Wir ballern das asynchron durch einen massiv parallelen Download-Pool, damit das so schnell wie möglich geht.

Du kannst dich an die Events hängen, um Ladebalken im Frontend zu füttern:

launcher.on('download_progress', (event) => {
    const percent = (event.bytesDownloaded / event.bytesTotal) * 100;
    updateProgressBar(percent);
    updateStatusText(`Lade Datei: ${event.currentFile}`);
});

Launch-Flags

Egal ob RAM-Zuweisung, Fenstergröße oder Custom JVM-Flags: Du hast die volle Kontrolle. Wenn du nichts angibst, setzen wir smarte Defaults passend zur Java-Version.

LaunchOptions options = new LaunchOptions.Builder()
    .setRamMb(8192) // 8GB RAM
    .setJavaPath("C:\\Program Files\\Java\\jdk-17\\bin\\java.exe")
    .setWindowSize(1920, 1080)
    .addJvmArgument("-XX:+UseG1GC")
    .build();

launcher.launch("1.20.4", auth, options);

Python Guide (Easy MC Launcher)

Die easy-mc-launcher Bibliothek ermöglicht die Entwicklung von Minecraft-Launchern in Python. Sie unterstützt grafische Benutzeroberflächen über die Builder-API sowie Headless-Anwendungen über die Core-API.

GUI Builder & WYSIWYG-Editor

Der Launcher kann visuell über den LauncherEditor erstellt oder per Code generiert werden. Die Builder-API rendert die UI nativ als moderne HTML/CSS-Desktop-App.

from easy_mc_launcher import LauncherBuilder

builder = LauncherBuilder(
    title="Planet Launcher",
    accent="#00d4ff",
    bg="#0a0e27"
)

builder.add_label("haupt_titel", text="Willkommen!", font_size=32, bold=True, center=True, color="#00d4ff")
builder.add_input("username", label="Spielername", default="Steve", required=True)
# options="auto" liest dynamisch alle Mojang-Versionen aus
builder.add_dropdown("version", label="Spielversion", options="auto")

builder.add_radio("ram", label="Arbeitsspeicher", options=[
    {"label": "2 GB", "value": "2G"},
    {"label": "4 GB", "value": "4G"},
    {"label": "8 GB", "value": "8G"}
], default="4G")

builder.add_button("play_button", text="SPIELEN", action="launch")
builder.add_progress("progress_bar")

builder.run()

Headless Core-API

Die EasyLauncher Klasse fungiert als Backend für eigene UI-Frameworks wie PyQt oder Tkinter. Sie übernimmt das Versionsmanagement und konfiguriert standardmäßig performante Garbage Collector JVM-Flags (ZGC/G1GC).

from easy_mc_launcher import EasyLauncher, SettingsManager

launcher = EasyLauncher()
settings = SettingsManager()

# Vanilla Start (lädt fehlende Assets automatisch)
# launcher.launch("1.20.1", settings)

# Forge Installation und Start
forge_version = launcher.install_forge("1.20.1-47.1.0")
launcher.launch(forge_version, settings)

Modifikationen (Mods & Shader)

Manager-Klassen erlauben die Verwaltung von Mods, Shadern und Resource Packs. Das System unterstützt das Soft-Disabling (Umbennen in .disabled), anstatt Dateien vollständig zu löschen.

from easy_mc_launcher import ModManager, ShaderPackManager

# Mods verwalten
mods = ModManager(launcher.minecraft_directory)
mods.download_mod("https://domain.de/mods/sodium.jar", "sodium.jar")
mods.disable_mod("sodium.jar") # Benennt zu sodium.jar.disabled um
print("Aktive Mods:", mods.get_installed_mods())

# Shader installieren
shaders = ShaderPackManager(launcher.minecraft_directory)
shaders.download_shader("https://domain.de/shaders/BSL.zip", "BSL.zip")

Welten-Management & Backups

Der WorldManager vereinfacht die Verwaltung von Singleplayer-Welten und ermöglicht automatisierte Backups.

from easy_mc_launcher import WorldManager

worlds = WorldManager(launcher.minecraft_directory)

for welt in worlds.get_worlds():
    groesse = worlds.get_world_size(welt["name"])
    print(f"Welt: {welt['name']} - {groesse} MB")

# Sichert den Ordner als ZIP im /backups Verzeichnis
worlds.backup_world("Local_Survival")
worlds.restore_backup("Local_Survival_backup_2024", restore_as="Survival_Restore")

Crash-Reporting & Server-Pinger

Das Backend integriert Diagnosetools zur Fehlerbehebung und Netzwerkanalyse.

from easy_mc_launcher import ServerPinger, CrashReporter

# Server-Status nativ über das Minecraft-Protokoll abfragen
info = ServerPinger.ping("mc.hypixel.net")
if info["online"]:
    print(f"Spieler online: {info['players_online']}/{info['players_max']}")

# Absturzberichte und Logs analysieren
crashes = CrashReporter(launcher.minecraft_directory)
summary = crashes.get_crash_summary()
if "error" not in summary:
    print(f"Letzter Absturz: {summary['exception']} in Version {summary['minecraft_version']}")

Node.js Guide

Der Go-To Weg für Apps mit Electron, Tauri oder reinem Node.

Beginner: Express Start

import { MinecraftLauncher, OfflineAuth } from 'easylauncher';

const launcher = new MinecraftLauncher('./.minecraft');
await launcher.install('1.20.4');
await launcher.launch({
    version: '1.20.4',
    auth: new OfflineAuth('Steve')
});

Pro: Electron IPC & Modloader

Nutz die IPC-Bridge, um Progress-Events sauber in deinen Renderer-Prozess (Frontend) durchzureichen.

import { ipcMain } from 'electron';
import { MinecraftLauncher, Modloaders } from 'easylauncher';

ipcMain.handle('launch-game', async (event, args) => {
    const launcher = new MinecraftLauncher(args.dir);
    
    launcher.on('progress', (data) => event.sender.send('dl-progress', data));
    
    await launcher.install('1.20.4', {
        modloader: new Modloaders.Fabric('0.15.7'),
        parallelDownloads: 16
    });
    
    return await launcher.launch({
        version: '1.20.4',
        memory: { min: '2G', max: '6G' }
    });
});

Java Guide

Basiert auf modernen Java 17 Features mit sauberen Callbacks für Swing oder JavaFX.

Beginner: Direkter Start

MinecraftLauncher launcher = new MinecraftLauncher(Path.of("./.minecraft"));
launcher.install(new Version("1.20.4"));
launcher.launch("1.20.4", new OfflineAuth("Player"));

Pro: Eigener Auth-Flow

Bau dir headless einen Launcher, zieh dir den Microsoft OAuth2 Flow und lies den stdout des Spiels direkt aus.

MicrosoftAuth auth = new MicrosoftAuth(CLIENT_ID);
auth.loginDeviceCode(code -> {
    System.out.println("Öffne: " + code.verificationUrl());
    System.out.println("Gib diesen Code ein: " + code.userCode());
}).thenAccept(session -> {
    LaunchProcess process = launcher.launch("1.20.4", session, 
        new LaunchOptions.Builder().setRamMb(8192).build()
    );
    
    process.onLogLine(line -> logger.info("[GAME_STDOUT] " + line));
});

Rust Guide

Baut auf tokio für kranke Performance und speichersichere asynchrone Downloads.

Beginner: Standard Start

use easylauncher::{MinecraftLauncher, auth::OfflineAuth};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let launcher = MinecraftLauncher::new("./.minecraft");
    launcher.install("1.20.4").await?;
    launcher.launch("1.20.4", OfflineAuth::new("Player")).await?;
    Ok(())
}

Pro: Totale Kontrolle

Klemm dich tief in den HTTP-Client, wirf Custom Header für Proxies rein oder pass den JRE-Provider komplett an.

use easylauncher::{MinecraftLauncher, config::LauncherConfig};

let config = LauncherConfig::builder()
    .proxy("http://localhost:8080")
    .custom_jre_provider(|version| {
        format!("https://mein-server.com/jre/{}-linux.tar.gz", version)
    })
    .build();

let launcher = MinecraftLauncher::with_config("./.minecraft", config);

let mut rx = launcher.install_with_channel("1.20.4").await?;
while let Some(event) = rx.recv().await {
    update_ui(event);
}