How to Use lighty-version

Basic Usage

Step 1: Initialize AppState

use lighty_core::AppState;

const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "MyLauncher";
const APPLICATION: &str = "";

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let _app = AppState::new(
        QUALIFIER.to_string(),
        ORGANIZATION.to_string(),
        APPLICATION.to_string(),
    )?;

    let launcher_dir = AppState::get_project_dirs();

    Ok(())
}

Step 2: Create VersionBuilder

use lighty_version::VersionBuilder;
use lighty_loaders::types::Loader;

// Vanilla instance
let vanilla = VersionBuilder::new(
    "vanilla-1.21",
    Loader::Vanilla,
    "",              // No loader version for Vanilla
    "1.21.1",
    launcher_dir
);

// Fabric instance
let fabric = VersionBuilder::new(
    "fabric-1.21",
    Loader::Fabric,
    "0.16.9",        // Fabric loader version
    "1.21.1",
    launcher_dir
);

// Quilt instance
let quilt = VersionBuilder::new(
    "quilt-1.21",
    Loader::Quilt,
    "0.27.1",        // Quilt loader version
    "1.21.1",
    launcher_dir
);

// NeoForge instance
let neoforge = VersionBuilder::new(
    "neoforge-1.21",
    Loader::NeoForge,
    "21.1.80",       // NeoForge version
    "1.21.1",
    launcher_dir
);

VersionBuilder Features

Get Version Information

use lighty_loaders::types::VersionInfo;

println!("Name: {}", vanilla.name());
println!("Loader: {:?}", vanilla.loader());
println!("Loader version: {}", vanilla.loader_version());
println!("Minecraft version: {}", vanilla.minecraft_version());
println!("Game directory: {}", vanilla.game_dirs().display());
println!("Java directory: {}", vanilla.java_dirs().display());
println!("Full ID: {}", vanilla.full_identifier());

Output:

Name: vanilla-1.21
Loader: Vanilla
Loader version:
Minecraft version: 1.21.1
Game directory: /home/user/.local/share/MyLauncher/vanilla-1.21
Java directory: /home/user/.config/MyLauncher/jre
Full ID: vanilla-1.21-1.21.1-

Custom Directories

use std::path::PathBuf;

let instance = VersionBuilder::new(
    "custom",
    Loader::Fabric,
    "0.16.9",
    "1.21.1",
    launcher_dir
)
.with_custom_game_dir(PathBuf::from("/opt/minecraft/instances/custom"))
.with_custom_java_dir(PathBuf::from("/usr/lib/jvm/java-21"));

println!("Game dir: {}", instance.game_dirs().display());
// Output: Game dir: /opt/minecraft/instances/custom

println!("Java dir: {}", instance.java_dirs().display());
// Output: Java dir: /usr/lib/jvm/java-21

Check Directory Existence

use lighty_loaders::types::VersionInfo;

if instance.game_dir_exists() {
    println!("Game directory exists");
} else {
    println!("Game directory needs to be created");
}

if instance.java_dir_exists() {
    println!("Java directory exists");
}

Get Both Directories

use lighty_loaders::types::VersionInfo;

let (game_dir, java_dir) = instance.paths();
println!("Game: {}", game_dir.display());
println!("Java: {}", java_dir.display());

LightyVersionBuilder (Custom Server)

For custom servers using LightyUpdater:

use lighty_core::AppState;
use lighty_version::LightyVersionBuilder;

const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "MyLauncher";
const APPLICATION: &str = "";

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let _app = AppState::new(
        QUALIFIER.to_string(),
        ORGANIZATION.to_string(),
        APPLICATION.to_string(),
    )?;

    let launcher_dir = AppState::get_project_dirs();

    // Create LightyUpdater instance
    let modpack = LightyVersionBuilder::new(
        "my-modpack",
        "https://myserver.com/api",
        launcher_dir
    );

    println!("Instance: {}", modpack.name());
    println!("Server API: {}", modpack.loader_version());

    Ok(())
}

Key Features:

• Connects to custom server API

• Downloads modpack manifest from server

• Automatically handles mod updates

• See LightyUpdater Repository for server setup

Using with LoaderExtensions

Both builders implement VersionInfo, enabling all loader operations:

use lighty_loaders::types::{VersionInfo, LoaderExtensions};

// VersionBuilder
let fabric = VersionBuilder::new(
    "fabric-1.21",
    Loader::Fabric,
    "0.16.9",
    "1.21.1",
    launcher_dir
);

// Get metadata (LoaderExtensions trait)
let metadata = fabric.get_metadata().await?;
println!("Main class: {}", metadata.main_class);
println!("Libraries: {}", metadata.libraries.len());

// Get specific parts
let libraries = fabric.get_libraries().await?;
let assets = fabric.get_assets().await?;

// LightyVersionBuilder
let modpack = LightyVersionBuilder::new(
    "modpack",
    "https://server.com/api",
    launcher_dir
);

// Same methods available
let metadata = modpack.get_metadata().await?;

Using with InstanceControl

Both builders also support instance management:

use lighty_launch::InstanceControl;

// Create instance
let mut instance = VersionBuilder::new(
    "my-game",
    Loader::Fabric,
    "0.16.9",
    "1.21.1",
    launcher_dir
);

// Get metadata
let metadata = instance.get_metadata().await?;

// Calculate size
let size = instance.size_of_instance(&metadata);
println!("Total: {:.2} GB", size.total_gb());

// Get running PID
if let Some(pid) = instance.get_pid() {
    println!("Running with PID: {}", pid);

    // Close instance
    instance.close_instance(pid).await?;
}

// Delete instance
instance.delete_instance().await?;

Complete Workflow

Standard Loader Workflow

use lighty_core::AppState;
use lighty_version::VersionBuilder;
use lighty_loaders::types::{Loader, VersionInfo, LoaderExtensions};
use lighty_launch::InstanceControl;
use lighty_auth::{offline::OfflineAuth, Authenticator};
use lighty_java::JavaDistribution;

const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "MyLauncher";
const APPLICATION: &str = "";

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. Initialize AppState
    let _app = AppState::new(
        QUALIFIER.to_string(),
        ORGANIZATION.to_string(),
        APPLICATION.to_string(),
    )?;

    let launcher_dir = AppState::get_project_dirs();

    // 2. Create instance
    let mut instance = VersionBuilder::new(
        "fabric-modded",
        Loader::Fabric,
        "0.16.9",
        "1.21.1",
        launcher_dir
    );

    println!("Instance: {}", instance.name());
    println!("Game dir: {}", instance.game_dirs().display());

    // 3. Get metadata
    let metadata = instance.get_metadata().await?;
    println!("Version: {}", metadata.id);
    println!("Libraries: {}", metadata.libraries.len());

    // 4. Calculate size
    let size = instance.size_of_instance(&metadata);
    println!("Size: {:.2} GB", size.total_gb());

    // 5. Authenticate
    let mut auth = OfflineAuth::new("Player123");

    #[cfg(not(feature = "events"))]
    let profile = auth.authenticate().await?;

    #[cfg(feature = "events")]
    let profile = auth.authenticate(None).await?;

    // 6. Launch
    instance.launch(&profile, JavaDistribution::Temurin)
        .run()
        .await?;

    println!("Game launched!");

    // 7. Get PID
    if let Some(pid) = instance.get_pid() {
        println!("Running with PID: {}", pid);
    }

    Ok(())
}

Custom Server Workflow

use lighty_core::AppState;
use lighty_version::LightyVersionBuilder;
use lighty_loaders::types::{VersionInfo, LoaderExtensions};
use lighty_launch::InstanceControl;
use lighty_auth::{microsoft::MicrosoftAuth, Authenticator};
use lighty_java::JavaDistribution;

const QUALIFIER: &str = "com";
const ORGANIZATION: &str = "MyLauncher";
const APPLICATION: &str = "";

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. Initialize AppState
    let _app = AppState::new(
        QUALIFIER.to_string(),
        ORGANIZATION.to_string(),
        APPLICATION.to_string(),
    )?;

    let launcher_dir = AppState::get_project_dirs();

    // 2. Create LightyUpdater instance
    let mut modpack = LightyVersionBuilder::new(
        "survival-modpack",
        "https://play.myserver.com/api",
        launcher_dir
    );

    println!("Modpack: {}", modpack.name());
    println!("Server: {}", modpack.loader_version());

    // 3. Get metadata from server
    let metadata = modpack.get_metadata().await?;
    println!("Minecraft: {}", metadata.id);
    println!("Mods: {}", metadata.mods.as_ref().map_or(0, |m| m.len()));

    // 4. Authenticate
    let mut auth = MicrosoftAuth::new("your-client-id");
    auth.set_device_code_callback(|code, url| {
        println!("Visit: {}", url);
        println!("Code: {}", code);
    });

    #[cfg(not(feature = "events"))]
    let profile = auth.authenticate().await?;

    #[cfg(feature = "events")]
    let profile = auth.authenticate(None).await?;

    // 5. Launch modpack
    modpack.launch(&profile, JavaDistribution::Temurin)
        .run()
        .await?;

    println!("Modpack launched!");

    Ok(())
}

Directory Structure

Both builders create the following structure:

game_dirs/
├── {instance-name}/         # Instance root
│   ├── versions/
│   │   └── {version}/
│   │       ├── {version}.json
│   │       └── {version}.jar
│   ├── libraries/           # Java libraries
│   ├── assets/              # Game assets
│   ├── mods/                # Mod files (if applicable)
│   ├── config/              # Mod configurations
│   └── saves/               # Worlds

java_dirs/
└── jre/                     # Java runtimes
    ├── java-8/
    ├── java-17/
    └── java-21/

Exports

In lighty_version:

use lighty_version::{
    VersionBuilder,
    LightyVersionBuilder,
};

In lighty_launcher:

use lighty_launcher::{
    version::{VersionBuilder, LightyVersionBuilder},
    // or via prelude
    prelude::*,  // Includes VersionBuilder
};

Related Documentation

• Overview - Architecture and design

• Exports - Complete export reference

• VersionBuilder - Standard builder details

• LightyVersionBuilder - Custom server builder details

• lighty-loaders Traits - VersionInfo and LoaderExtensions

Related Crates

• lighty-loaders - VersionInfo trait and loaders

• lighty-core - AppState for project directories

• lighty-launch - Uses VersionBuilder for launching

• lighty-auth - User authentication

• lighty-java - Java runtime management