4 files changed, 549 insertions, 247 deletions

diff --git a/src/minecraft/downloads.rs b/src/minecraft/downloads.rs
index 7017d3f..8df994e 100644
--- a/src/minecraft/downloads.rs
+++ b/src/minecraft/downloads.rs
@@ -1,181 +1,360 @@
-use log::{debug, info};
-use reqwest::get;
+use std::{
+    collections::HashMap,
+    io::{Write, stdout},
+    path::{Path, PathBuf},
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+};
+
+use McError::Config;
+use Ordering::SeqCst;
+use futures::stream::{FuturesUnordered, StreamExt};
+use reqwest::Response;
 use serde::Deserialize;
 use tokio::{
-    fs::{self, File, create_dir_all},
+    fs::{File, create_dir_all, read_to_string, write},
     io::AsyncWriteExt,
+    spawn,
+    sync::Semaphore,
+    task::{JoinError, JoinHandle},
 };
 
 use crate::{
-    config::Config,
+    config::RuntimeConfig,
     errors::McError,
-    minecraft::manifests::{Library, Version},
-    platform::paths,
+    minecraft::manifests::{AssetIndex, Library, LibraryArtifact, Version},
+    platform::paths::{assets_directory, client_jar, library_file},
 };
 
+const MAX_CONCURRENT_DOWNLOADS: usize = 100;
+const PROGRESS_INITIAL_VALUE: usize = 0;
+const ASSET_URL_BASE: &str = "https://resources.download.minecraft.net/";
+const MAX_PROGRESS_PERCENT: f64 = 100.0;
+const PROGRESS_PRINT_WIDTH: usize = 3;
+const ATOMIC_ORDERING: Ordering = SeqCst;
+const DOWNLOAD_COMPLETE_MESSAGE: &str = "All downloads completed successfully!";
+const ASSET_INDEX_MISSING_ERROR: &str = "Missing asset_index for the version";
+
+impl From<JoinError> for McError {
+    fn from(error: JoinError) -> Self {
+        Config(format!("Task panicked: {}", error))
+    }
+}
+
+/// Represents a single file to download, including the URL and destination
+/// path.
+#[derive(Debug, Clone)]
+struct DownloadJob {
+    url: String,
+    destination_path: PathBuf,
+}
+
+impl DownloadJob {
+    fn already_exists(&self) -> bool { self.destination_path.exists() }
+}
+
+/// Represents a single asset entry in the Minecraft asset index.
 #[derive(Debug, Deserialize)]
 struct AssetObject {
     hash: String,
-    // size: u64,
 }
 
+/// The Minecraft asset index manifest.
 #[derive(Debug, Deserialize)]
 struct AssetIndexManifest {
-    objects: std::collections::HashMap<String, AssetObject>,
+    objects: HashMap<String, AssetObject>,
 }
 
-pub async fn download_all(
-    config: &Config,
-    version: &Version,
+/// Download all files required to run a specific Minecraft version.
+pub async fn download_all_files(
+    http_client: &reqwest::Client,
+    runtime_config: &RuntimeConfig,
+    version_info: &Version,
 ) -> Result<(), McError> {
-    download_client(config, version).await?;
-    download_libraries(config, &version.libraries).await?;
-    download_assets(config, version).await?;
+    let assets_directory_path: PathBuf =
+        ensure_assets_directories_exist(runtime_config).await?;
+    let asset_manifest: AssetIndexManifest = load_asset_index_manifest(
+        http_client,
+        &assets_directory_path,
+        version_info,
+    )
+    .await?;
+
+    let download_jobs: Vec<DownloadJob> = build_download_jobs(
+        runtime_config,
+        version_info,
+        &assets_directory_path,
+        &asset_manifest,
+    );
+
+    execute_download_jobs(http_client, download_jobs).await?;
+    println!("\n{}", DOWNLOAD_COMPLETE_MESSAGE);
+
     Ok(())
 }
 
-async fn download_client(
-    config: &Config,
-    version: &Version,
-) -> Result<(), McError> {
-    let jar_path = paths::client_jar(config, &version.id)?;
-
-    if jar_path.exists() {
-        debug!("Client jar already exists: {}", jar_path.display());
-        return Ok(());
-    }
-
-    info!("Downloading client {}", version.id);
-    download_file(&version.downloads.client.url, &jar_path).await
+/// Ensure the essential assets directories exist.
+async fn ensure_assets_directories_exist(
+    config: &RuntimeConfig,
+) -> Result<PathBuf, McError> {
+    let assets_dir = assets_directory(config);
+    create_dir_all(assets_dir.join("objects")).await?;
+    create_dir_all(assets_dir.join("indexes")).await?;
+    Ok(assets_dir)
 }
 
-async fn download_libraries(
-    config: &Config,
-    libraries: &[Library],
-) -> Result<(), McError> {
-    for library in libraries {
-        if let Some(artifact) = &library.downloads.artifact {
-            let library_path = paths::library_file(config, &artifact.path)?;
-
-            if !library_path.exists() {
-                info!("Downloading library {}", artifact.path);
-                download_file(&artifact.url, &library_path).await?;
-            }
-        }
-
-        if let Some(classifiers) = &library.downloads.classifiers {
-            for (_, native) in classifiers {
-                let native_path = paths::library_file(config, &native.path)?;
+/// Load the asset index manifest for the given Minecraft version.
+async fn load_asset_index_manifest(
+    http_client: &reqwest::Client,
+    assets_dir: &Path,
+    version_info: &Version,
+) -> Result<AssetIndexManifest, McError> {
+    let asset_index: &AssetIndex = version_info
+        .asset_index
+        .as_ref()
+        .ok_or_else(|| Config(ASSET_INDEX_MISSING_ERROR.into()))?;
 
-                if native_path.exists() {
-                    continue;
-                }
+    let index_file_path: PathBuf = assets_dir
+        .join("indexes")
+        .join(format!("{}.json", asset_index.id));
 
-                info!("Downloading native library {}", native.path);
-                download_file(&native.url, &native_path).await?;
-            }
-        }
+    if !index_file_path.exists() {
+        download_text_file(http_client, &asset_index.url, &index_file_path)
+            .await?;
     }
 
-    Ok(())
+    let json_string: String = read_to_string(index_file_path).await?;
+    Ok(serde_json::from_str(&json_string)?)
 }
 
-async fn download_asset_index(
-    config: &Config,
-    version: &Version,
-) -> Result<AssetIndexManifest, McError> {
-    let assets_dir = paths::assets_dir(config);
-    create_dir_all(assets_dir.join("indexes")).await?;
+fn build_download_jobs(
+    config: &RuntimeConfig,
+    version_info: &Version,
+    assets_dir: &Path,
+    asset_manifest: &AssetIndexManifest,
+) -> Vec<DownloadJob> {
+    let mut jobs: Vec<DownloadJob> = Vec::new();
 
-    let asset_index = version.asset_index.as_ref().ok_or_else(|| {
-        McError::Config("Missing asset_index in version.json".into())
-    })?;
+    add_client_download_job(&mut jobs, config, version_info);
+    add_library_download_jobs(&mut jobs, config, version_info);
+    add_asset_download_jobs(&mut jobs, assets_dir, asset_manifest);
 
-    if asset_index.id == "legacy" {
-        return Err(McError::Config(
-            "Legacy assetIndex detected – pobierz właściwy version.json".into(),
-        ));
-    }
+    jobs
+}
 
-    let index_path = assets_dir
-        .join("indexes")
-        .join(format!("{}.json", asset_index.id));
+fn add_client_download_job(
+    jobs: &mut Vec<DownloadJob>,
+    config: &RuntimeConfig,
+    version_info: &Version,
+) {
+    jobs.push(DownloadJob {
+        url: version_info.downloads.client.url.clone(),
+        destination_path: client_jar(config, &version_info.id),
+    });
+}
 
-    if index_path.exists() {
-        let index_data = fs::read_to_string(&index_path).await?;
-        let manifest: AssetIndexManifest = serde_json::from_str(&index_data)?;
-        return Ok(manifest);
+fn add_library_download_jobs(
+    jobs: &mut Vec<DownloadJob>,
+    config: &RuntimeConfig,
+    version_info: &Version,
+) {
+    for library in &version_info.libraries {
+        add_library_artifact_job(jobs, config, library);
+        add_library_classifier_jobs(jobs, config, library);
     }
+}
+fn add_library_artifact_job(
+    jobs: &mut Vec<DownloadJob>,
+    config: &RuntimeConfig,
+    library: &Library,
+) {
+    let artifact: &LibraryArtifact = match &library.downloads.artifact {
+        | Some(a) => a,
+        | None => return,
+    };
+
+    jobs.push(DownloadJob {
+        url: artifact.url.clone(),
+        destination_path: library_file(config, &artifact.path),
+    });
+}
 
-    info!("Downloading asset index {}", asset_index.id);
-    let response = get(&asset_index.url).await?;
-    let manifest_text = response.text().await?;
-
-    fs::write(&index_path, &manifest_text).await?;
+fn add_library_classifier_jobs(
+    jobs: &mut Vec<DownloadJob>,
+    config: &RuntimeConfig,
+    library: &Library,
+) {
+    let classifiers: &HashMap<String, LibraryArtifact> =
+        match &library.downloads.classifiers {
+            | Some(values) => values,
+            | None => return,
+        };
+
+    for classifier_entry in classifiers.values() {
+        jobs.push(DownloadJob {
+            url: classifier_entry.url.clone(),
+            destination_path: library_file(config, &classifier_entry.path),
+        });
+    }
+}
 
-    let manifest: AssetIndexManifest = serde_json::from_str(&manifest_text)?;
-    Ok(manifest)
+fn add_asset_download_jobs(
+    jobs: &mut Vec<DownloadJob>,
+    assets_dir: &Path,
+    asset_manifest: &AssetIndexManifest,
+) {
+    for asset_object in asset_manifest.objects.values() {
+        let prefix: &str = &asset_object.hash[0..2];
+        jobs.push(DownloadJob {
+            url: format!("{}{}/{}", ASSET_URL_BASE, prefix, asset_object.hash),
+            destination_path: assets_dir
+                .join("objects")
+                .join(prefix)
+                .join(&asset_object.hash),
+        });
+    }
 }
 
-async fn download_assets(
-    config: &Config,
-    version: &Version,
+async fn execute_download_jobs(
+    http_client: &reqwest::Client,
+    download_jobs: Vec<DownloadJob>,
 ) -> Result<(), McError> {
-    let assets_dir = paths::assets_dir(config);
-
-    create_dir_all(assets_dir.join("objects")).await?;
-    create_dir_all(assets_dir.join("indexes")).await?;
-
-    let manifest = download_asset_index(config, version).await?;
+    let total_jobs_count: usize = download_jobs.len();
+    let completed_jobs_count: Arc<AtomicUsize> =
+        Arc::new(AtomicUsize::new(PROGRESS_INITIAL_VALUE));
+    let concurrent_download_semaphore: Arc<Semaphore> =
+        Arc::new(Semaphore::new(MAX_CONCURRENT_DOWNLOADS));
+
+    let mut tasks: FuturesUnordered<JoinHandle<Result<(), McError>>> =
+        spawn_missing_download_jobs(
+            http_client,
+            download_jobs,
+            &completed_jobs_count,
+            total_jobs_count,
+            concurrent_download_semaphore,
+        );
 
-    for (logical_path, asset) in &manifest.objects {
-        let subdir = &asset.hash[0..2];
-        let file_path = assets_dir
-            .join("objects")
-            .join(subdir)
-            .join(&asset.hash);
+    await_download_tasks(&mut tasks).await
+}
 
-        if file_path.exists() {
+fn spawn_missing_download_jobs(
+    http_client: &reqwest::Client,
+    download_jobs: Vec<DownloadJob>,
+    completed_jobs_counter: &Arc<AtomicUsize>,
+    total_jobs_count: usize,
+    concurrent_download_semaphore: Arc<Semaphore>,
+) -> FuturesUnordered<JoinHandle<Result<(), McError>>> {
+    let download_tasks: FuturesUnordered<JoinHandle<Result<(), McError>>> =
+        FuturesUnordered::new();
+
+    for job in download_jobs {
+        if job.already_exists() {
+            completed_jobs_counter.fetch_add(1, SeqCst);
+            print_download_progress(completed_jobs_counter, total_jobs_count);
             continue;
         }
 
-        let url = format!(
-            "https://resources.download.minecraft.net/{}/{}",
-            subdir, asset.hash
-        );
-        info!("Downloading asset {} -> {}", logical_path, file_path.display());
-        download_file(&url, &file_path).await?;
+        download_tasks.push(spawn_download_job(
+            http_client.clone(),
+            job,
+            concurrent_download_semaphore.clone(),
+            completed_jobs_counter.clone(),
+            total_jobs_count,
+        ));
     }
 
-    if let Some(asset) = manifest.objects.get("sounds.json") {
-        let file_path = assets_dir.join("indexes").join("sounds.json");
-        if !file_path.exists() {
-            let subdir = &asset.hash[0..2];
-            let url = format!(
-                "https://resources.download.minecraft.net/{}/{}",
-                subdir, asset.hash
-            );
-            info!("Downloading sounds.json");
-            download_file(&url, &file_path).await?;
-        }
+    download_tasks
+}
+
+async fn await_download_tasks(
+    tasks: &mut FuturesUnordered<JoinHandle<Result<(), McError>>>,
+) -> Result<(), McError> {
+    while let Some(task_result) = tasks.next().await {
+        task_result.map_err(McError::from)??;
     }
+    Ok(())
+}
 
+fn spawn_download_job(
+    http_client: reqwest::Client,
+    download_job: DownloadJob,
+    concurrent_download_semaphore: Arc<Semaphore>,
+    completed_jobs_count: Arc<AtomicUsize>,
+    total_jobs_count: usize,
+) -> JoinHandle<Result<(), McError>> {
+    spawn(async move {
+        let _permit = concurrent_download_semaphore
+            .acquire_owned()
+            .await
+            .unwrap();
+        download_file(&http_client, &download_job).await?;
+        completed_jobs_count.fetch_add(1, SeqCst);
+        print_download_progress(&completed_jobs_count, total_jobs_count);
+        Ok(())
+    })
+}
+
+/// Print the current progress of downloads to stdout.
+///
+/// # Parameters
+/// - `completed_jobs_count`: Atomic counter of completed download jobs.
+/// - `total_jobs_count`: Total number of jobs being processed.
+fn print_download_progress(
+    completed_jobs_count: &AtomicUsize,
+    total_jobs_count: usize,
+) {
+    let completed_jobs: usize = completed_jobs_count.load(ATOMIC_ORDERING);
+    let progress_percentage: f64 = ((completed_jobs as f64
+        / total_jobs_count as f64)
+        * MAX_PROGRESS_PERCENT)
+        .min(MAX_PROGRESS_PERCENT);
+
+    print!(
+        "\rDownloading game files: {:>width$.0}%",
+        progress_percentage,
+        width = PROGRESS_PRINT_WIDTH
+    );
+    stdout().flush().unwrap();
+}
+
+async fn download_text_file(
+    http_client: &reqwest::Client,
+    file_url: &str,
+    destination_path: &PathBuf,
+) -> Result<(), McError> {
+    let text_content = http_client
+        .get(file_url)
+        .send()
+        .await?
+        .error_for_status()?
+        .text()
+        .await?;
+    write(destination_path, text_content).await?;
     Ok(())
 }
 
 async fn download_file(
-    url: &str,
-    path: &std::path::Path,
+    http_client: &reqwest::Client,
+    download_job: &DownloadJob,
 ) -> Result<(), McError> {
-    if let Some(parent) = path.parent() {
-        create_dir_all(parent).await?;
+    if let Some(parent_dir) = download_job.destination_path.parent() {
+        create_dir_all(parent_dir).await?;
     }
 
-    let response = get(url).await?;
-    let bytes = response.bytes().await?;
-
-    let mut file = File::create(path).await?;
-    file.write_all(&bytes).await?;
+    let response: Response = http_client
+        .get(&download_job.url)
+        .send()
+        .await?
+        .error_for_status()?;
+    let mut byte_stream = response.bytes_stream();
+    let mut file_handle: File =
+        File::create(&download_job.destination_path).await?;
+
+    while let Some(chunk) = byte_stream.next().await {
+        file_handle.write_all(&chunk?).await?;
+    }
 
     Ok(())
 }
diff --git a/src/minecraft/extraction.rs b/src/minecraft/extraction.rs
index b58fd2e..292566f 100644
--- a/src/minecraft/extraction.rs
+++ b/src/minecraft/extraction.rs
@@ -1,11 +1,17 @@
-use std::{fs, io, path::Path};
+use std::{
+    collections::HashMap,
+    fs,
+    fs::File,
+    io,
+    path::{Path, PathBuf},
+};
 
-use log::info;
-use zip::ZipArchive;
+use zip::{read::ZipFile, ZipArchive};
 
 use crate::{
     errors::McError,
-    minecraft::manifests::{Library, Version},
+    minecraft::manifests::{LibraryArtifact, Version},
+    util::fs::library_allowed,
 };
 
 pub fn extract_natives(
@@ -19,8 +25,6 @@ pub fn extract_natives(
         .join(&version.id)
         .join("natives");
 
-    info!("Extracting natives for {} into {:?}", version.id, natives_dir);
-
     if natives_dir.exists() {
         fs::remove_dir_all(&natives_dir)?;
     }
@@ -31,75 +35,51 @@ pub fn extract_natives(
             continue;
         }
 
-        let natives = match &lib.natives {
+        let natives: &HashMap<String, String> = match &lib.natives {
             | Some(n) => n,
             | None => continue,
         };
 
-        let classifier = match natives.get("linux") {
+        let classifier: &String = match natives.get("linux") {
             | Some(c) => c,
             | None => continue,
         };
 
-        let classifiers = match &lib.downloads.classifiers {
-            | Some(c) => c,
-            | None => continue,
-        };
+        let classifiers: &HashMap<String, LibraryArtifact> =
+            match &lib.downloads.classifiers {
+                | Some(c) => c,
+                | None => continue,
+            };
 
-        let artifact = match classifiers.get(classifier) {
+        let artifact: &LibraryArtifact = match classifiers.get(classifier) {
             | Some(a) => a,
             | None => continue,
         };
 
-        let jar_path = cfg
+        let jar_path: PathBuf = cfg
             .data_dir
             .join("minecraft")
             .join("libraries")
             .join(&artifact.path);
 
-        info!("Extracting natives from {:?}", jar_path);
-
         extract_zip(&jar_path, &natives_dir)?;
     }
 
     Ok(())
 }
-
-fn library_allowed(lib: &Library) -> bool {
-    let rules = match &lib.rules {
-        | Some(r) => r,
-        | None => return true,
-    };
-
-    let mut allowed = false;
-
-    for rule in rules {
-        let os_match = match &rule.os {
-            | Some(os) => os.name == "linux",
-            | None => true,
-        };
-
-        if os_match {
-            allowed = rule.action == "allow";
-        }
-    }
-
-    allowed
-}
-
 fn extract_zip(jar_path: &Path, out_dir: &Path) -> Result<(), McError> {
-    let file = fs::File::open(jar_path)?;
-    let mut zip = ZipArchive::new(file)?;
+    let file: File = File::open(jar_path)?;
+    let mut zip: ZipArchive<File> = ZipArchive::new(file)?;
 
     for i in 0..zip.len() {
-        let mut entry = zip.by_index(i)?;
-        let name = entry.name();
+        let mut entry: ZipFile<File> = zip.by_index(i)?;
+        let name: &str = entry.name();
 
         if name.starts_with("META-INF/") {
             continue;
         }
 
-        let out_path = out_dir.join(name);
+        let out_path: PathBuf = out_dir.join(name);
 
         if entry.is_dir() {
             fs::create_dir_all(&out_path)?;
@@ -110,7 +90,7 @@ fn extract_zip(jar_path: &Path, out_dir: &Path) -> Result<(), McError> {
             fs::create_dir_all(parent)?;
         }
 
-        let mut out_file = fs::File::create(&out_path)?;
+        let mut out_file: File = File::create(&out_path)?;
         io::copy(&mut entry, &mut out_file)?;
     }
 
diff --git a/src/minecraft/launcher.rs b/src/minecraft/launcher.rs
index 2eeaf21..3cca948 100644
--- a/src/minecraft/launcher.rs
+++ b/src/minecraft/launcher.rs
@@ -1,64 +1,104 @@
-use std::process::Command;
-
-use log::{debug, info};
+use paths::{client_jar, library_file, natives_dir};
+use serde::Deserialize;
+use std::path::Path;
+use std::process::Output;
+use std::{
+    path::PathBuf,
+    process::{Command, ExitStatus},
+};
+use McError::Process;
 
 use crate::{
-    config::Config,
-    errors::McError,
-    minecraft::manifests::{Library, Version},
-    platform::paths,
+    config::Config, errors::McError, minecraft::manifests::Version,
+    platform::paths, util::fs::library_allowed,
 };
 
-fn build_classpath(
-    config: &Config,
-    version: &Version,
-) -> Result<String, McError> {
-    let sep = if cfg!(windows) { ";" } else { ":" };
-    let mut entries = Vec::new();
+#[derive(Debug, Clone, Deserialize)]
+pub struct JavaRuntime {
+    pub major: u8,
+    pub path: PathBuf,
+}
+
+impl JavaRuntime {
+    fn validate(&self) -> Result<(), McError> {
+        let output: Output = Command::new(&self.path)
+            .arg("-version")
+            .output()
+            .map_err(|e| {
+                McError::Runtime(format!(
+                    "Failed to execute Java at {}: {}",
+                    self.path.display(),
+                    e
+                ))
+            })?;
+
+        if !output.status.success() {
+            return Err(McError::Runtime(format!(
+                "Invalid Java binary: {}",
+                self.path.display()
+            )));
+        }
+
+        Ok(())
+    }
+}
+
+fn required_java_major(java_major: Option<u8>) -> u8 {
+    java_major.unwrap_or(8)
+}
+
+fn resolve_runtime(
+    required: u8,
+    runtimes: &[JavaRuntime],
+) -> Result<PathBuf, McError> {
+    let mut candidates: Vec<&JavaRuntime> = runtimes
+        .iter()
+        .filter(|r| r.major >= required)
+        .collect();
+
+    candidates.sort_by_key(|r| r.major);
+
+    let runtime = candidates.first().ok_or_else(|| {
+        McError::Runtime(format!(
+            "No suitable Java runtime found (required: Java {})",
+            required
+        ))
+    })?;
+
+    runtime.validate()?;
+    Ok(runtime.path.clone())
+}
+
+fn build_classpath(config: &Config, version: &Version) -> String {
+    let system_separator: &str = if cfg!(windows) { ";" } else { ":" };
+    let mut entries: Vec<String> = Vec::new();
 
     for library in &version.libraries {
         if !library_allowed(library) {
             continue;
         }
+
         if let Some(artifact) = &library.downloads.artifact {
-            let path = paths::library_file(config, &artifact.path)?;
+            let path = library_file(config, &artifact.path);
             entries.push(path.to_string_lossy().to_string());
         }
     }
 
-    let client_jar = paths::client_jar(config, &version.id)?;
-    entries.push(client_jar.to_string_lossy().to_string());
+    let client: PathBuf = client_jar(config, &version.id);
+    entries.push(client.to_string_lossy().to_string());
 
-    Ok(entries.join(sep))
+    entries.join(system_separator)
 }
 
-pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
-    let java = &config.java_path;
-    let classpath = build_classpath(config, version)?;
-    let natives_dir = paths::natives_dir(config, &version.id);
-
-    if !natives_dir.exists() {
-        return Err(McError::Runtime(format!(
-            "Natives folder does not exist: {}",
-            natives_dir.display()
-        )));
-    }
-
-    let asset_index_id = version
-        .asset_index
-        .as_ref()
-        .ok_or_else(|| {
-            McError::Runtime("Missing assetIndex in version.json".into())
-        })?
-        .id
-        .clone();
-
-    info!("Launching Minecraft {}", version.id);
-    debug!("Classpath: {}", classpath);
-    debug!("Natives: {}", natives_dir.display());
-    debug!("Asset index: {}", asset_index_id);
-
-    let mut cmd = Command::new(java);
+fn build_command(
+    java_path: PathBuf,
+    config: &Config,
+    version: &Version,
+    natives_dir: &Path,
+    classpath: String,
+    asset_index_id: String,
+) -> Command {
+    let mut cmd: Command = Command::new(java_path);
 
     cmd.arg(format!("-Xmx{}M", config.max_memory_mb))
         .arg(format!("-Djava.library.path={}", natives_dir.display()));
@@ -76,11 +116,11 @@ pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
         .arg("--version")
         .arg(&version.id)
         .arg("--gameDir")
-        .arg(paths::game_dir(config))
+        .arg(paths::game_directory(config))
         .arg("--assetsDir")
-        .arg(paths::assets_dir(config))
+        .arg(paths::assets_directory(config))
         .arg("--assetIndex")
-        .arg(&asset_index_id)
+        .arg(asset_index_id)
         .arg("--uuid")
         .arg(&config.uuid)
         .arg("--userProperties")
@@ -90,32 +130,128 @@ pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
         .arg("--userType")
         .arg("legacy");
 
-    let status = cmd.status()?;
+    cmd
+}
+
+pub fn launch(config: &Config, version: &Version) -> Result<(), McError> {
+    let required: u8 = required_java_major(
+        version
+            .java_version
+            .as_ref()
+            .map(|j| j.major_version),
+    );
+
+    let java_path: PathBuf = resolve_runtime(required, &config.runtimes)?;
+
+    let classpath: String = build_classpath(config, version);
+    let natives_dir: PathBuf = natives_dir(config, &version.id);
+
+    if !natives_dir.exists() {
+        return Err(McError::Runtime(format!(
+            "Natives folder does not exist: {}",
+            natives_dir.display()
+        )));
+    }
+
+    let asset_index_id = version
+        .asset_index
+        .as_ref()
+        .ok_or_else(|| {
+            McError::Runtime("Missing assetIndex in version.json".into())
+        })?
+        .id
+        .clone();
+
+    let mut cmd: Command = build_command(
+        java_path,
+        config,
+        version,
+        &natives_dir,
+        classpath,
+        asset_index_id,
+    );
+
+    let status: ExitStatus = cmd.status()?;
 
     if !status.success() {
-        return Err(McError::Process("Minecraft exited with error".into()));
+        return Err(Process("Minecraft exited with error".into()));
     }
 
     Ok(())
 }
 
-fn library_allowed(lib: &Library) -> bool {
-    let rules = match &lib.rules {
-        | Some(r) => r,
-        | None => return true,
-    };
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn required_java_major_defaults_to_8() {
+        assert_eq!(required_java_major(None), 8);
+    }
+
+    #[test]
+    fn required_java_major_uses_given_value() {
+        assert_eq!(required_java_major(Some(17)), 17);
+    }
+
+    #[test]
+    fn resolve_runtime_errors_when_no_runtimes() {
+        let runtimes: Vec<JavaRuntime> = vec![];
+        assert!(resolve_runtime(17, &runtimes).is_err());
+    }
+
+    #[test]
+    fn resolve_runtime_picks_lowest_matching_major() {
+        let runtimes: Vec<JavaRuntime> = vec![
+            JavaRuntime {
+                major: 21,
+                path: PathBuf::from("/bin/true"),
+            },
+            JavaRuntime {
+                major: 17,
+                path: PathBuf::from("/bin/true"),
+            },
+        ];
+
+        let result: PathBuf = resolve_runtime(8, &runtimes).unwrap();
+        assert_eq!(result, PathBuf::from("/bin/true"));
+    }
 
-    let mut allowed = false;
+    #[test]
+    fn resolve_runtime_respects_required_version() {
+        let runtimes: Vec<JavaRuntime> = vec![
+            JavaRuntime {
+                major: 8,
+                path: PathBuf::from("/bin/true"),
+            },
+            JavaRuntime {
+                major: 17,
+                path: PathBuf::from("/bin/true"),
+            },
+        ];
+
+        let result: PathBuf = resolve_runtime(17, &runtimes).unwrap();
+        assert_eq!(result, PathBuf::from("/bin/true"));
+    }
 
-    for rule in rules {
-        let os_match = match &rule.os {
-            | Some(os) => os.name == "linux",
-            | None => true,
+    #[test]
+    fn validate_succeeds_for_true_binary() {
+        let runtime = JavaRuntime {
+            major: 17,
+            path: PathBuf::from("/bin/true"),
         };
-        if os_match {
-            allowed = rule.action == "allow";
-        }
+
+        assert!(runtime.validate().is_ok());
     }
 
-    allowed
+    #[test]
+    fn validate_fails_for_false_binary() {
+        let runtime = JavaRuntime {
+            major: 17,
+            path: PathBuf::from("/bin/false"),
+        };
+
+        assert!(runtime.validate().is_err());
+    }
 }
diff --git a/src/minecraft/manifests.rs b/src/minecraft/manifests.rs
index 8bdec26..64e38da 100644
--- a/src/minecraft/manifests.rs
+++ b/src/minecraft/manifests.rs
@@ -1,11 +1,18 @@
 #![allow(dead_code)]
 
-use std::collections::HashMap;
-
-use reqwest;
+use crate::{constants::VERSION_MANIFEST_URL, errors::McError};
+use reqwest::get;
 use serde::Deserialize;
+use serde_json::{from_str, Value};
+use std::collections::HashMap;
+use McError::Config;
 
-use crate::{constants::VERSION_MANIFEST_URL, errors::McError};
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JavaVersionInfo {
+    pub component: String,
+    pub major_version: u8,
+}
 
 #[derive(Debug, Deserialize)]
 pub struct Version {
@@ -19,6 +26,10 @@ pub struct Version {
 
     #[serde(rename = "assetIndex")]
     pub asset_index: Option<AssetIndex>,
+
+    #[serde(default)]
+    #[serde(rename = "javaVersion")]
+    pub java_version: Option<JavaVersionInfo>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -83,15 +94,13 @@ pub struct OsRule {
 pub async fn load_version(
     cfg: &crate::config::Config,
 ) -> Result<Version, McError> {
-    let manifest_text = reqwest::get(VERSION_MANIFEST_URL)
-        .await?
-        .text()
-        .await?;
-    let root: serde_json::Value = serde_json::from_str(&manifest_text)?;
+    let manifest_text = get(VERSION_MANIFEST_URL).await?.text().await?;
+    let root: Value = from_str(&manifest_text)?;
+
     let version_id = if cfg.version == "latest" {
         root["latest"]["release"]
             .as_str()
-            .ok_or_else(|| McError::Config("missing latest.release".into()))?
+            .ok_or_else(|| Config("missing latest.release".into()))?
             .to_string()
     } else {
         cfg.version.clone()
@@ -99,21 +108,19 @@ pub async fn load_version(
 
     let versions = root["versions"]
         .as_array()
-        .ok_or_else(|| McError::Config("missing versions array".into()))?;
+        .ok_or_else(|| Config("missing versions array".into()))?;
 
     let version_entry = versions
         .iter()
         .find(|v| v["id"].as_str() == Some(&version_id))
-        .ok_or_else(|| {
-            McError::Config(format!("version '{}' not found", version_id))
-        })?;
+        .ok_or_else(|| Config(format!("version '{}' not found", version_id)))?;
 
     let url = version_entry["url"]
         .as_str()
-        .ok_or_else(|| McError::Config("missing version url".into()))?;
+        .ok_or_else(|| Config("missing version url".into()))?;
 
-    let version_text = reqwest::get(url).await?.text().await?;
-    let version: Version = serde_json::from_str(&version_text)?;
+    let version_text = get(url).await?.text().await?;
+    let version: Version = from_str(&version_text)?;
 
     Ok(version)
 }