Introduction

EasyLauncher is a straightforward library that makes building custom Minecraft launchers easy, no matter what programming language you use.

Instead of figuring out how the Microsoft login works or parsing complicated Mojang JSON files, EasyLauncher handles all the background work for you. We don't provide a UI, which means you have total freedom to design your launcher however you want.

Note: We are a backend library. You build the interface (in React, Swing, Tkinter, Tauri, etc.), and we handle the Minecraft logic.

Installation

Grab the package for your favorite language from the standard package managers.

npm install easylauncher-node

pip install easylauncher

cargo add easylauncher

<dependency>
    <groupId>dev.easylauncher</groupId>
    <artifactId>easylauncher-core</artifactId>
    <version>2.0.0</version>
</dependency>

Quickstart

Here's a fast example of how to launch vanilla Minecraft with Python:

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

# Create the launcher pointing to the game folder
launcher = MinecraftLauncher(directory="./.minecraft")

# Pick a simple offline account (or use Microsoft login)
account = OfflineAuth("Notch")

# Download the game files
launcher.install(Version("1.20.4"))

# Boot up the game
launcher.launch(
    version="1.20.4",
    auth=account,
    ram_mb=4096
)

Authentication

EasyLauncher supports quick Offline logins (for testing or cracked servers) and the official Microsoft Login.

Security Tip: Don't store passwords in plain text. EasyLauncher automatically caches tokens securely for you.

Offline Login

Great for local testing.

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

Microsoft Login

To use real accounts, just trigger the interactive login flow. We handle the Xbox Live stuff behind the scenes.

import { MicrosoftAuth } from 'easylauncher';

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

// Opens the browser for the user to sign in
const session = await auth.loginInteractive();
console.log(`Logged in as ${session.profile.name}`);

Version Resolution

Want to find out what the latest Minecraft version is? EasyLauncher pulls this straight from Mojang.

use easylauncher::versions::VersionManifest;

// Grab the newest release
let manifest = VersionManifest::fetch().await?;
let latest_release = manifest.latest.release;

println!("Newest version: {}", latest_release);

Modloaders (Fabric / Forge)

Installing Fabric or Forge is super simple. Just pass the modloader config when you install the game.

from easylauncher.modloaders import Fabric

# Downloads Minecraft 1.20.4 AND sets up Fabric
launcher.install(Version("1.20.4"), modloader=Fabric(loader_version="0.15.7"))

Asset Downloading

Minecraft needs a lot of files to run. We download them using multiple threads at once to make it as fast as possible.

You can listen to the download events to update your progress bars in the UI:

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

Launch Arguments

You have full control over memory limits and JVM arguments, but we set smart defaults for you if you don't want to mess with them.

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)

The easy-mc-launcher library allows you to build Minecraft launchers in Python. It supports graphical user interfaces via the Builder API, as well as headless applications using the Core API.

GUI Builder & WYSIWYG Editor

The launcher can be built visually using the LauncherEditor or generated via code. The Builder API renders the UI natively as a modern 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="Welcome!", font_size=32, bold=True, center=True, color="#00d4ff")
builder.add_input("username", label="Player Name", default="Steve", required=True)
# options="auto" dynamically fetches all Mojang versions
builder.add_dropdown("version", label="Game Version", options="auto")

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

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

builder.run()

Headless Core API

The EasyLauncher class functions as a backend for custom UI frameworks like PyQt or Tkinter. It handles version management and sets high-performance JVM garbage collection flags (ZGC/G1GC) by default.

from easy_mc_launcher import EasyLauncher, SettingsManager

launcher = EasyLauncher()
settings = SettingsManager()

# Launch Vanilla (downloads missing assets automatically)
# launcher.launch("1.20.1", settings)

# Install and launch Forge
forge_version = launcher.install_forge("1.20.1-47.1.0")
launcher.launch(forge_version, settings)

Modifications (Mods & Shaders)

Manager classes allow you to handle mods, shaders, and resource packs. The system supports soft-disabling (renaming to .disabled) instead of permanently deleting files.

from easy_mc_launcher import ModManager, ShaderPackManager

# Manage Mods
mods = ModManager(launcher.minecraft_directory)
mods.download_mod("https://domain.com/mods/sodium.jar", "sodium.jar")
mods.disable_mod("sodium.jar") # Renames to sodium.jar.disabled
print("Active Mods:", mods.get_installed_mods())

# Install Shaders
shaders = ShaderPackManager(launcher.minecraft_directory)
shaders.download_shader("https://domain.com/shaders/BSL.zip", "BSL.zip")

World Management & Backups

The WorldManager simplifies the management of single-player worlds and enables automated backups.

from easy_mc_launcher import WorldManager

worlds = WorldManager(launcher.minecraft_directory)

for world in worlds.get_worlds():
    size = worlds.get_world_size(world["name"])
    print(f"World: {world['name']} - {size} MB")

# Backs up the directory as a ZIP in the /backups folder
worlds.backup_world("Local_Survival")
worlds.restore_backup("Local_Survival_backup_2024", restore_as="Survival_Restore")

Crash Reporting & Server Pinger

The backend integrates diagnostic tools for troubleshooting and network analysis.

from easy_mc_launcher import ServerPinger, CrashReporter

# Check server status natively via the Minecraft protocol
info = ServerPinger.ping("mc.hypixel.net")
if info["online"]:
    print(f"Players online: {info['players_online']}/{info['players_max']}")

# Analyze crash reports and logs
crashes = CrashReporter(launcher.minecraft_directory)
summary = crashes.get_crash_summary()
if "error" not in summary:
    print(f"Last Crash: {summary['exception']} in version {summary['minecraft_version']}")

Node.js Guide

Perfect for building desktop apps with Electron or Tauri.

Beginner: Express Launch

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 & Modloaders

Use Electron's IPC to send download progress directly to your frontend UI.

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

Built with modern Java 17 features. Great for standard desktop launchers.

Beginner: Quick Launch

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

Pro: Custom Auth Flow

Hook into the full Microsoft Device Code flow and read the game logs directly.

MicrosoftAuth auth = new MicrosoftAuth(CLIENT_ID);
auth.loginDeviceCode(code -> {
    System.out.println("Go to: " + code.verificationUrl());
    System.out.println("Enter code: " + code.userCode());
}).thenAccept(session -> {
    LaunchProcess process = launcher.launch("1.20.4", session, 
        new LaunchOptions.Builder().setRamMb(8192).build()
    );
    
    process.onLogLine(line -> logger.info("[GAME] " + line));
});

Rust Guide

Uses tokio for incredibly fast, memory-safe downloading and launching.

Beginner: Standard Launch

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: Total Customization

Configure custom proxies or JRE download links if you're hosting files yourself.

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

let config = LauncherConfig::builder()
    .proxy("http://localhost:8080")
    .custom_jre_provider(|version| {
        format!("https://my-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);
}