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

Das Python-Package ist strikt typisiert und voll auf asyncio ausgelegt.

Beginner: Schneller Start

Der schnellste Weg zum Startbildschirm mit dem synchronen Wrapper.

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

launcher = MinecraftLauncher(directory="./.minecraft")
launcher.install(Version("1.20.4"))
launcher.launch(version="1.20.4", auth=OfflineAuth("Player"))

Pro: Async & Customization

Für richtige GUIs (wie PyQt) nutzt du die Async-API. So friert dein Main-Thread nicht ein, wenn du dich an das Event-System hängst.

import asyncio
from easylauncher.asyncio import AsyncMinecraftLauncher
from easylauncher.events import DownloadProgressEvent

async def main():
    launcher = AsyncMinecraftLauncher(directory="./.minecraft")
    
    @launcher.on(DownloadProgressEvent)
    async def on_progress(event):
        print(f"{event.downloaded_files}/{event.total_files} Dateien geladen")
        
    await launcher.install_async("1.20.4")
    process = await launcher.launch_async("1.20.4")
    await process.wait()

asyncio.run(main())

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);
}