Feat: Refactor core download logic with concurrency and async features

Implement basic unit testing

Implement automatic java executable switching based on game version

Split loader module into smaller modules

Implement basic documentation

18 files changed, 1560 insertions, 377 deletions

diff --git a/.gitignore b/.gitignore
index d0f7565..95a9573 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ Cargo.lock
 *.pdb
 rust-project.json
 *.png
+.idea
diff --git a/.run/Run dml.run.xml b/.run/Run dml.run.xml
new file mode 100644
index 0000000..dd66d28
--- /dev/null
+++ b/.run/Run dml.run.xml
@@ -0,0 +1,20 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Run dml" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="buildProfileId" value="dev" />
+    <option name="command" value="run --package dml --bin dml" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <envs />
+    <option name="emulateTerminal" value="true" />
+    <option name="channel" value="STABLE" />
+    <option name="requiredFeatures" value="true" />
+    <option name="allFeatures" value="true" />
+    <option name="withSudo" value="true" />
+    <option name="buildTarget" value="REMOTE" />
+    <option name="backtrace" value="SHORT" />
+    <option name="isRedirectInput" value="false" />
+    <option name="redirectInputPath" value="" />
+    <method v="2">
+      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 9c0eb1b..c72e1c6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,10 +8,8 @@ clap = { version = "4.5.54", features = ["derive"] }
 directories = "6.0.0"
 dotenvy = "0.15.7"
 env_logger = "0.11.8"
-futures-util = "0.3.31"
-indicatif = "0.18.3"
+futures = "0.3.32"
 log = "0.4.29"
-rayon = "1.11.0"
 reqwest = { version = "0.13.1", features = ["json", "stream"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
diff --git a/README.md b/README.md
index a9bdf0f..46c3255 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,13 @@
-# Very simple minecraft launcher (early stage of development). Made to explore concurrency/async in rust.
+# Very simple minecraft launcher (early stage of development). Made to explore concurrency/async in rust. And because I don't like the default launcher.
 
 ## Available features
 
-- [x] playing any version > 1.10
+- [x] playing any version >1.7 and <1.15
 
 ## Planned features
 
-- [] "modern" minecraft
+- [ ] Concurrent asset downloading
 
-- [] modloaders
-
-- [] Concurrent asset downloading
+- [ ] modloaders
 
+- [ ] "modern" minecraft
diff --git a/src/config/file.rs b/src/config/file.rs
new file mode 100644
index 0000000..17f2cb2
--- /dev/null
+++ b/src/config/file.rs
@@ -0,0 +1,26 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
+use crate::minecraft::launcher::JavaRuntime;
+
+#[derive(Debug, Deserialize)]
+pub struct FileConfig {
+    pub username: String,
+    pub uuid: String,
+    pub version: String,
+    pub max_memory_mb: u32,
+
+    #[serde(default)]
+    pub jvm_args: Vec<String>,
+
+    #[serde(default)]
+    pub runtimes: Vec<JavaRuntime>,
+
+    #[serde(default)]
+    pub java_path: String,
+
+    pub data_dir: PathBuf,
+    // pub cache_dir: PathBuf,
+    // pub config_dir: PathBuf,
+}
diff --git a/src/config/loader.rs b/src/config/loader.rs
index d4b142e..47514e5 100644
--- a/src/config/loader.rs
+++ b/src/config/loader.rs
@@ -1,65 +1,90 @@
-use std::{env::var, fs::read_to_string, path::PathBuf};
-
+use std::{env, fs::read_to_string, path::PathBuf};
 use directories::ProjectDirs;
-use serde::Deserialize;
+use uuid::Uuid;
 
+use super::{file::FileConfig, runtime::RuntimeConfig};
 use crate::{constants::*, errors::McError};
-#[allow(dead_code)]
-#[derive(Debug, Deserialize)]
-pub struct Config {
-    pub username: String,
-    pub uuid: String,
-    pub version: String,
-    pub java_path: String,
-    pub max_memory_mb: u32,
-    pub data_dir: PathBuf,
-    pub cache_dir: PathBuf,
-    pub config_dir: PathBuf,
-    #[serde(default)]
-    pub jvm_args: Vec<String>,
-}
-impl Config {
-    pub fn load() -> Result<Self, McError> {
-        let cfg_path = default_config_path()?;
-        let mut cfg: Config = if cfg_path.exists() {
-            let txt = read_to_string(&cfg_path)?;
-            toml::from_str(&txt).map_err(|e| McError::Config(e.to_string()))?
+
+pub struct ConfigLoader;
+
+impl ConfigLoader {
+    pub fn load(cfg_file: Option<&PathBuf>) -> Result<RuntimeConfig, McError> {
+        let path = match cfg_file {
+            | Some(p) => p.clone(),
+            | None => Self::default_config_path()?,
+        };
+
+        let mut file_cfg = if path.exists() {
+            Self::read_file(&path)?
         } else {
-            Self::default()
+            Self::default_file_config()?
         };
-        if let Ok(v) = var("MC_USERNAME") {
-            cfg.username = v;
-        }
-        if let Ok(v) = var("MC_VERSION") {
-            cfg.version = v;
-        }
-        if let Ok(v) = var("MC_JAVA_PATH") {
-            cfg.java_path = v;
-        }
-        if let Ok(v) = var("MC_MAX_MEMORY_MB") {
-            cfg.max_memory_mb = v.parse().unwrap_or(cfg.max_memory_mb);
-        }
-        Ok(cfg)
+
+        Self::apply_env_overrides(&mut file_cfg);
+
+        Ok(RuntimeConfig::from_file(file_cfg))
+    }
+
+    fn read_file(path: &PathBuf) -> Result<FileConfig, McError> {
+        let content = read_to_string(path).map_err(|e| {
+            McError::Config(format!(
+                "Failed to read config file {}: {}",
+                path.display(),
+                e
+            ))
+        })?;
+
+        toml::from_str(&content).map_err(|e| {
+            McError::Config(format!("Failed to parse config file: {}", e))
+        })
     }
 
-    fn default() -> Self {
-        let base =
-            ProjectDirs::from("com", "example", "dml").expect("platform dirs");
-        Self {
-            username: "Player".into(),
-            uuid: uuid::Uuid::new_v4().to_string(),
+    fn apply_env_overrides(cfg: &mut FileConfig) {
+        cfg.username = env::var(ENV_USERNAME)
+            .unwrap_or_else(|_| DEFAULT_USERNAME.to_string());
+
+        cfg.version = env::var(ENV_VERSION)
+            .unwrap_or_else(|_| DEFAULT_VERSION.to_string());
+
+        cfg.java_path = env::var(ENV_JAVA_PATH)
+            .unwrap_or_else(|_| DEFAULT_JAVA_PATH.to_string());
+
+        cfg.max_memory_mb = env::var(ENV_MAX_MEMORY_MB)
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(DEFAULT_MAX_MEMORY_MB);
+    }
+
+    fn default_config_path() -> Result<PathBuf, McError> {
+        let base = ProjectDirs::from(
+            DEFAULT_COMPANY,
+            DEFAULT_PROJECT_GROUP,
+            DEFAULT_PROJECT_NAME,
+        )
+        .ok_or_else(|| McError::Config(DEFAULT_ERR_PLATFORM_DIR.into()))?;
+
+        Ok(base.config_dir().join(DEFAULT_CONFIG_FILENAME))
+    }
+
+    fn default_file_config() -> Result<FileConfig, McError> {
+        let base = ProjectDirs::from(
+            DEFAULT_COMPANY,
+            DEFAULT_PROJECT_GROUP,
+            DEFAULT_PROJECT_NAME,
+        )
+        .ok_or_else(|| McError::Config(DEFAULT_ERR_PLATFORM_DIR.into()))?;
+
+        Ok(FileConfig {
+            username: DEFAULT_USERNAME.into(),
+            uuid: Uuid::new_v4().to_string(),
             version: DEFAULT_VERSION.into(),
-            java_path: DEFAULT_JAVA_PATH.into(),
             max_memory_mb: DEFAULT_MAX_MEMORY_MB,
+            java_path: DEFAULT_JAVA_PATH.into(),
             data_dir: base.data_dir().into(),
-            cache_dir: base.cache_dir().into(),
-            config_dir: base.config_dir().into(),
+            // cache_dir: base.cache_dir().into(),
+            // config_dir: base.config_dir().into(),
             jvm_args: vec![],
-        }
+            runtimes: vec![],
+        })
     }
 }
-fn default_config_path() -> Result<PathBuf, McError> {
-    let base = ProjectDirs::from("com", "example", "dml")
-        .ok_or_else(|| McError::Config("cannot determine config dir".into()))?;
-    Ok(base.config_dir().join("config.toml"))
-}
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 066154a..a375dda 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -1,12 +1,11 @@
 //! Configuration module for the DML launcher.
-//!
-//! This module contains submodules and helpers for loading, parsing, and
-//! managing configuration files and settings. It abstracts the details
-//! of where configuration is stored and how it is represented in memory.
-//!
-//! # Submodules
-//! - `loader`: Functions to load and parse configuration from disk or
-//!   environment variables.
 
+pub mod file;
 pub mod loader;
-pub use loader::Config;
+pub mod runtime;
+
+pub use loader::ConfigLoader;
+pub use runtime::RuntimeConfig;
+
+/// Backwards-compatibility alias so existing code can keep using `Config`
+pub type Config = RuntimeConfig;
diff --git a/src/config/runtime.rs b/src/config/runtime.rs
new file mode 100644
index 0000000..46857f0
--- /dev/null
+++ b/src/config/runtime.rs
@@ -0,0 +1,95 @@
+use std::path::PathBuf;
+
+use super::file::FileConfig;
+use crate::{constants::*, minecraft::launcher::JavaRuntime};
+
+/// Configuration for the runtime environment used to launch Minecraft.
+///
+/// The `RuntimeConfig` struct holds the configuration settings required to
+/// launch Minecraft with a specific Java runtime. This includes details about
+/// the user, the Minecraft version, the available Java runtimes, and JVM options.
+///
+/// The `RuntimeConfig` struct is typically used by the launcher to store and
+/// manage the necessary settings for running the game. It also supports
+/// dynamic configuration by allowing the addition of Java runtimes and the
+/// specification of system paths and arguments.
+#[derive(Debug)]
+#[derive(Default)]
+pub struct RuntimeConfig {
+    /// The username of the player running Minecraft.
+    pub username: String,
+
+    /// The UUID (unique identifier) of the user.
+    pub uuid: String,
+
+    /// The version of Minecraft that the user is running.
+    pub version: String,
+
+    /// The maximum amount of memory (in megabytes) allocated to the Java process.
+    /// This setting determines how much memory the Minecraft instance can use.
+    pub max_memory_mb: u32,
+
+    /// A list of arguments to pass to the JVM when launching Minecraft.
+    /// These arguments can be used to customize the JVM's behavior, such as
+    /// memory settings, garbage collection options, etc.
+    pub jvm_args: Vec<String>,
+
+    /// A list of Java runtime environments available for Minecraft.
+    /// If no specific Java runtime is provided, the default one is used.
+    pub runtimes: Vec<JavaRuntime>,
+
+    /// The directory where Minecraft data (e.g., worlds, logs, configs) is stored.
+    /// This path is critical for loading and saving game data.
+    pub data_dir: PathBuf,
+}
+
+impl RuntimeConfig {
+    /// Creates a new `RuntimeConfig` instance from a `FileConfig`.
+    ///
+    /// This method takes a `FileConfig` object (typically loaded from a configuration file)
+    /// and constructs a `RuntimeConfig` instance. It ensures that if no runtimes are defined
+    /// but a Java path is provided, a default Java runtime is created based on the specified path.
+    ///
+    /// # Parameters
+    /// - `file`: A `FileConfig` instance containing initial configuration values for the
+    ///   Minecraft runtime. This includes user details, Minecraft version, JVM arguments,
+    ///   and the path to Java (if specified).
+    ///
+    /// # Returns
+    /// - A `RuntimeConfig` instance initialized with the values from `file`. If no runtimes
+    ///   were provided in `file` but a Java path was given, the method will add a default Java runtime.
+    ///
+    /// # Example
+    /// ```rust
+    /// let file_config = FileConfig {
+    ///     username: "Player1".into(),
+    ///     uuid: "1234-5678-9101".into(),
+    ///     version: "1.18.2".into(),
+    ///     max_memory_mb: 2048,
+    ///     jvm_args: vec!["-Xmx2G".into()],
+    ///     runtimes: Vec::new(),
+    ///     java_path: "/path/to/java".into(),
+    ///     data_dir: "/path/to/minecraft/data".into(),
+    /// };
+    ///
+    /// let runtime_config = RuntimeConfig::from_file(file_config);
+    /// ```
+    pub fn from_file(mut file: FileConfig) -> Self {
+        if file.runtimes.is_empty() && !file.java_path.is_empty() {
+            file.runtimes.push(JavaRuntime {
+                major: DEFAULT_JAVA_MAJOR,
+                path: PathBuf::from(&file.java_path),
+            });
+        }
+
+        Self {
+            username: file.username,
+            uuid: file.uuid,
+            version: file.version,
+            max_memory_mb: file.max_memory_mb,
+            jvm_args: file.jvm_args,
+            runtimes: file.runtimes,
+            data_dir: file.data_dir,
+        }
+    }
+}
diff --git a/src/constants.rs b/src/constants.rs
index 3234fe6..72de325 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,13 +1,123 @@
 #![allow(dead_code)]
 
+//! Constants module for the DML Launcher.
+//!
+//! This module defines immutable configuration values and defaults
+//! used throughout the launcher. These constants provide a single
+//! source of truth for URLs, download behavior, memory settings,
+//! JVM defaults, download concurrency, directory names, and version selection.
+//!
+//! Centralizing these constants ensures consistency across the
+//! application and simplifies maintenance when defaults need to change.
+
 use std::time::Duration;
 
+/// URL to the Minecraft version manifest.
+///
+/// This manifest contains metadata for all available Minecraft
+/// releases, including release dates, type (release, snapshot),
+/// and download URLs for the client and server distributions.
 pub const VERSION_MANIFEST_URL: &str =
     "https://launchermeta.mojang.com/mc/game/version_manifest.json";
 
+/// Number of times to retry a failed download.
+///
+/// Used by asset and library download routines to tolerate
+/// transient network failures. Downloads will be retried
+/// up to this number of attempts before returning an error.
 pub const DOWNLOAD_RETRIES: usize = 3;
+
+/// Duration to wait between download retries.
+///
+/// Provides fixed delay for network resilience when fetching
+/// game assets. Specified in milliseconds.
 pub const DOWNLOAD_BACKOFF: Duration = Duration::from_millis(400);
 
+/// Default maximum memory allocation for the Minecraft JVM process in
+/// megabytes.
+///
+/// If the user does not specify memory settings via configuration
+/// or JVM arguments, this value will be applied as the default heap size.
 pub const DEFAULT_MAX_MEMORY_MB: u32 = 4048;
+
+/// Default path to the Java executable.
+///
+/// Used when launching the Minecraft client. Can be overridden
+/// via configuration or environment variables if a custom Java
+/// installation is required.
 pub const DEFAULT_JAVA_PATH: &str = "java";
+
+/// Default Minecraft version to launch when no specific version is provided.
+///
+/// The launcher will resolve "latest" to the most recent stable release
+/// according to the version manifest.
 pub const DEFAULT_VERSION: &str = "latest";
+
+/// Default Java major version for launching Minecraft.
+///
+/// This value is used when generating the JVM runtime configuration
+/// for the launcher.
+pub const DEFAULT_JAVA_MAJOR: u8 = 8;
+
+/// Default number of concurrent downloads for libraries.
+///
+/// Limits the number of simultaneous HTTP requests when fetching
+/// Minecraft libraries to avoid saturating network or file handles.
+pub const DEFAULT_LIBRARY_CONCURRENCY: usize = 20;
+
+/// Default number of concurrent downloads for assets.
+///
+/// Limits the number of simultaneous HTTP requests when fetching
+/// Minecraft assets to optimize throughput without overloading the system.
+pub const DEFAULT_ASSET_CONCURRENCY: usize = 20;
+
+/// Default launcher cache directory name.
+///
+/// Used as the base subdirectory for downloaded assets, libraries,
+/// versions, and configuration.
+pub const DEFAULT_LAUNCHER_DIR: &str = "dml";
+
+/// Default environment variable names for overriding configuration.
+pub const ENV_USERNAME: &str = "MC_USERNAME";
+pub const ENV_VERSION: &str = "MC_VERSION";
+pub const ENV_JAVA_PATH: &str = "MC_JAVA_PATH";
+pub const ENV_MAX_MEMORY_MB: &str = "MC_MAX_MEMORY_MB";
+
+/// Default project/platform constants for `directories::ProjectDirs`.
+pub const DEFAULT_COMPANY: &str = "com";
+pub const DEFAULT_PROJECT_GROUP: &str = "example";
+pub const DEFAULT_PROJECT_NAME: &str = "dml";
+
+/// Default error messages for common failures.
+pub const DEFAULT_ERR_PLATFORM_DIR: &str = "cannot determine config dir";
+pub const DEFAULT_ERR_CREATE_DIR: &str = "failed to create directory";
+
+/// Default configuration filename within the launcher directory.
+pub const DEFAULT_CONFIG_FILENAME: &str = "config.toml";
+
+/// Default username if none is provided by environment or config.
+pub const DEFAULT_USERNAME: &str = "phil";
+
+/// Default subdirectory names within the launcher directory.
+pub mod directory {
+    /// Directory for Minecraft versions.
+    pub const VERSIONS: &str = "versions";
+
+    /// Directory for downloaded libraries.
+    pub const LIBRARIES: &str = "libraries";
+
+    /// Directory for Minecraft assets.
+    pub const ASSETS: &str = "assets";
+
+    /// Subdirectory for asset indexes.
+    pub const INDEXES: &str = "indexes";
+
+    /// Subdirectory for asset objects.
+    pub const OBJECTS: &str = "objects";
+
+    /// Directory for native libraries.
+    pub const NATIVES: &str = "natives";
+
+    /// Directory for saved worlds.
+    pub const SAVES: &str = "saves";
+}
diff --git a/src/errors.rs b/src/errors.rs
index b98ae2d..bb9c985 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,45 +1,337 @@
 use std::{fmt, io};
 
 use fmt::{Display, Formatter, Result};
+use io::Error;
 use zip::result::ZipError;
 
-/// Represents all possible errors that can occur in the DML launcher.
+/// Central error type for the DML launcher.
 ///
-/// This enum centralizes error handling for the entire application,
-/// wrapping various underlying error types from I/O, HTTP requests,
-/// JSON parsing, ZIP extraction, configuration issues, and runtime errors.
+/// # Overview
+///
+/// `McError` provides a unified error abstraction for the entire
+/// application. Instead of exposing multiple unrelated error types
+/// across modules, all recoverable failures are represented through
+/// this single enum.
+///
+/// This design offers several advantages:
+///
+/// - Simplified function signatures (`Result<T, McError>`)
+/// - Seamless propagation using the `?` operator
+/// - Centralized error categorization
+/// - Clear separation between infrastructure errors and logical failures
+///
+/// # Error Categories
+///
+/// The variants fall into two broad categories:
+///
+/// 1. Wrapped external errors   These variants encapsulate errors originating
+///    from third-party libraries or the standard library.
+///
+/// 2. Application-defined errors   These variants represent logical or
+///    domain-specific failures unique to the launcher.
+///
+/// All variants are intentionally explicit to preserve failure context
+/// and avoid opaque error strings.
+///
+/// # Example
+///
+/// ```ignore
+/// fn load_config(path: &str) -> Result<Config, McError> {
+///     let data = read_to_string(path)?;
+///     let config = from_str(&data)?;
+///     Ok(config)
+/// }
+/// ```
+///
+/// In this example, both `io::Error` and `serde_json::Error`
+/// automatically convert into `McError` via the provided `From`
+/// implementations.
 #[allow(dead_code)]
 #[derive(Debug)]
 pub enum McError {
-    Io(io::Error),
+    /// Errors originating from the standard I/O subsystem.
+    ///
+    /// Typical causes:
+    /// - File system access failures
+    /// - Permission errors
+    /// - Missing files or directories
+    /// - Broken pipes
+    ///
+    /// Wraps: `std::io::Error`
+    Io(Error),
+
+    /// Errors occurring during HTTP communication.
+    ///
+    /// Typical causes:
+    /// - Network connectivity failures
+    /// - Timeouts
+    /// - TLS negotiation errors
+    /// - Invalid HTTP responses
+    ///
+    /// Wraps: `reqwest::Error`
     Http(reqwest::Error),
+
+    /// Errors encountered while parsing or serializing JSON.
+    ///
+    /// Typical causes:
+    /// - Malformed configuration files
+    /// - Invalid API responses
+    /// - Schema mismatches
+    ///
+    /// Wraps: `serde_json::Error`
     Json(serde_json::Error),
+
+    /// Errors related to ZIP archive handling.
+    ///
+    /// Typical causes:
+    /// - Corrupted archives
+    /// - Unsupported compression methods
+    /// - Extraction failures
+    ///
+    /// Wraps: `zip::result::ZipError`
     Zip(ZipError),
+
+    /// Configuration-related failures detected by the application.
+    ///
+    /// This variant is used when configuration data is syntactically
+    /// valid but semantically incorrect or incomplete.
+    ///
+    /// The contained string should describe the specific issue.
     Config(String),
+
+    /// Indicates a checksum verification failure.
+    ///
+    /// This is typically used when validating downloaded files
+    /// against an expected SHA hash. A mismatch suggests corruption,
+    /// incomplete transfer, or tampering.
+    ///
+    /// The contained string should identify the failing resource.
     ShaMismatch(String),
+
+    /// Represents a failure when spawning or interacting with
+    /// an external process.
+    ///
+    /// Typical causes:
+    /// - Executable not found
+    /// - Non-zero exit status
+    /// - Failed argument construction
+    ///
+    /// The contained string provides additional diagnostic detail.
     Process(String),
+
+    /// A general-purpose runtime error.
+    ///
+    /// This variant is intended for unexpected logical failures
+    /// that do not fall into other specific categories.
+    ///
+    /// It should not be used as a catch-all replacement for
+    /// more precise error variants.
     Runtime(String),
 }
 
+/// User-facing formatting implementation.
+///
+/// This implementation of the `Display` trait delegates to the `Debug` representation of the enum,
+/// providing a full structural view of the error. This includes all internal details such as the
+/// variant type and wrapped error information, which is particularly useful during development and debugging.
+///
+/// The `Debug` representation might be too verbose for production use, where more concise, user-friendly
+/// error messages would be beneficial. A future enhancement may be to implement a custom `Display` formatting
+/// for each error variant, providing a cleaner, more readable message for end users./// User-facing formatting implementation.
+///
+/// Currently delegates to the `Debug` representation of the enum.
+/// This preserves full structural information and wrapped error
+/// details, which is useful during development and debugging.
+///
+/// For production environments, a more refined implementation
+/// may format each variant explicitly to produce cleaner,
+/// user-oriented error messages.
 impl Display for McError {
-    /// Formats the error for user-friendly display.
-    ///
-    /// Currently, it uses the `Debug` format for simplicity.
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result { write!(f, "{:?}", self) }
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{:?}", self)
+    }
 }
 
-impl From<io::Error> for McError {
-    fn from(e: io::Error) -> Self { Self::Io(e) }
+/// Enables conversion from `std::io::Error` to `McError`.
+///
+/// This implementation allows any `std::io::Error` (e.g., file I/O errors) to be automatically converted into
+/// the `McError::Io` variant. This conversion is crucial when using the `?` operator within functions returning
+/// `Result<T, McError>`, as it ensures that I/O errors are properly handled and propagated as part of the unified
+/// `McError` error type.
+///
+/// This reduces the need for manual conversions and simplifies error handling in functions that involve I/O operations.
+impl From<Error> for McError {
+    fn from(e: Error) -> Self {
+        Self::Io(e)
+    }
 }
 
+/// Enables conversion from `reqwest::Error` to `McError`.
+///
+/// This implementation allows `reqwest::Error` (such as errors from HTTP requests) to be seamlessly converted
+/// into the `McError::Http` variant. This is particularly useful for error handling in functions that involve HTTP
+/// requests, as it allows HTTP-related failures to propagate naturally into the `McError` type and be handled
+/// consistently with other error types.
+///
+/// This conversion makes it easy to work with `reqwest` errors without worrying about mixing error types in the
+/// function signature.
 impl From<reqwest::Error> for McError {
-    fn from(e: reqwest::Error) -> Self { Self::Http(e) }
+    fn from(e: reqwest::Error) -> Self {
+        Self::Http(e)
+    }
 }
 
+/// Enables conversion from `serde_json::Error` to `McError`.
+///
+/// This implementation simplifies handling JSON parsing and serialization errors by converting any `serde_json::Error`
+/// (e.g., invalid JSON format, deserialization failure) into the `McError::Json` variant. This allows JSON errors
+/// to be handled in the same way as other error types, enabling uniform error management across the application.
+///
+/// By using this conversion, developers don't have to manually map JSON-related errors to a custom error type,
+/// reducing boilerplate and improving readability.
 impl From<serde_json::Error> for McError {
-    fn from(e: serde_json::Error) -> Self { Self::Json(e) }
+    fn from(e: serde_json::Error) -> Self {
+        Self::Json(e)
+    }
 }
 
+/// Enables conversion from `ZipError` to `McError`.
+///
+/// This implementation allows errors from ZIP archive operations (such as invalid or corrupted archives) to be
+/// converted into the `McError::Zip` variant. This makes it easy to integrate ZIP archive operations into the
+/// `McError` error handling model, ensuring consistency in how errors are propagated across the application.
+///
+/// This conversion allows the use of the `?` operator for ZIP-related errors, making error handling in ZIP operations
+/// as seamless as with other error types.
 impl From<ZipError> for McError {
-    fn from(e: ZipError) -> Self { Self::Zip(e) }
+    fn from(e: ZipError) -> Self {
+        Self::Zip(e)
+    }
+}
+
+/// Tests the `Display` trait implementation for each `McError` variant.
+///
+/// This test ensures that the `Display` formatting for all `McError` variants results in a non-empty string.
+/// It verifies that each variant can be correctly converted to a string, even though the current implementation
+/// delegates to `Debug`. This test is crucial for confirming that the `Display` implementation is functioning
+/// as expected for all error variants.
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use io::ErrorKind::Other;
+    use reqwest::Client;
+    use serde_json::{from_str, Value};
+    use std::io;
+    use std::io::Error;
+    use McError::{Config, Io, Json, Process, Runtime, ShaMismatch, Zip};
+    use ZipError::InvalidArchive;
+
+    fn create_error_variants() -> Vec<McError> {
+        vec![
+            Io(Error::new(Other, "io")),
+            Json(from_str::<Value>("not json").unwrap_err()),
+            Zip(InvalidArchive("zip".into())),
+            Config("config".into()),
+            ShaMismatch("sha".into()),
+            Process("process".into()),
+            Runtime("runtime".into()),
+        ]
+    }
+
+    #[test]
+    fn display_formats_error_variants() {
+        let error_variants = create_error_variants();
+
+        for error in error_variants {
+            let display_str = format!("{}", error);
+            assert!(!display_str.is_empty());
+        }
+    }
+
+    /// Tests the conversion from `std::io::Error` to `McError::Io`.
+    ///
+    /// This test ensures that an I/O error of type `std::io::Error` is correctly converted to the `McError::Io`
+    /// variant. The test checks that the string representation of the I/O error matches the expected value and
+    /// verifies that the conversion process is seamless. This test is essential for confirming the correct behavior
+    /// of the `From<Error>` implementation for I/O errors.
+    #[test]
+    fn from_io_error() {
+        let io_error: Error = Error::new(Other, "oops");
+        let mc_error: McError = io_error.into();
+
+        match mc_error {
+            | Io(e) => assert_eq!(e.to_string(), "oops"),
+            | _ => panic!("Expected McError::Io, but got: {:?}", mc_error),
+        }
+    }
+
+    /// Tests the conversion from `serde_json::Error` to `McError::Json`.
+    ///
+    /// This test ensures that a `serde_json::Error`, which occurs when JSON parsing or serialization fails,
+    /// is correctly converted into the `McError::Json` variant. The test checks that the error is appropriately
+    /// transformed and can be matched against the `McError::Json` variant.
+    #[test]
+    fn from_json_error() {
+        let json_error: serde_json::Error =
+            from_str::<Value>("not json").unwrap_err();
+        let mc_error: McError = json_error.into();
+
+        assert!(matches!(mc_error, Json(_)));
+    }
+
+    /// Tests the conversion from `ZipError` to `McError::Zip`.
+    ///
+    /// This test ensures that a `ZipError`, typically arising from invalid ZIP archive operations,
+    /// is converted to the `McError::Zip` variant. This ensures that ZIP-related errors are handled
+    /// in the same way as other error types, maintaining consistency in error propagation across the application.
+    #[test]
+    fn from_zip_error() {
+        let zip_error = InvalidArchive("bad zip".into());
+        let mc_error: McError = zip_error.into();
+
+        assert!(matches!(mc_error, Zip(_)));
+    }
+
+    /// Tests the conversion from `reqwest::Error` to `McError::Http`.
+    ///
+    /// This test ensures that HTTP-related errors from `reqwest` (e.g., failed requests, connection issues)
+    /// are correctly converted into the `McError::Http` variant. It confirms that HTTP-related failures
+    /// are properly integrated into the unified `McError` error type and handled in the same way as other errors.
+    #[tokio::test]
+    async fn from_reqwest_error() {
+        let client: Client = Client::new();
+        let request_error: reqwest::Error = client
+            .get("http://127.0.0.1:0")
+            .send()
+            .await
+            .unwrap_err();
+
+        let mc_error: McError = request_error.into();
+
+        assert!(
+            matches!(mc_error, McError::Http(_)),
+            "Expected McError::Http, got: {:?}",
+            mc_error
+        );
+    }
+
+    /// Tests that `Config`, `ShaMismatch`, `Process`, and `Runtime` variants are formatted consistently.
+    ///
+    /// This test checks that the `Display` and `Debug` formats are the same for the `Config`, `ShaMismatch`,
+    /// `Process`, and `Runtime` variants of `McError`. The test ensures that these variants are correctly
+    /// formatted both for user-facing display (`Display`) and for debugging purposes (`Debug`),
+    /// confirming consistency between the two formats.
+    #[test]
+    fn config_sha_process_runtime_variants() {
+        let error_variants = vec![
+            Config("bad config".into()),
+            ShaMismatch("bad sha".into()),
+            Process("failed process".into()),
+            Runtime("runtime error".into()),
+        ];
+
+        for error in error_variants {
+            assert_eq!(format!("{}", error), format!("{:?}", error));
+        }
+    }
 }
diff --git a/src/main.rs b/src/main.rs
index e229a3e..4b32c51 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,47 +1,116 @@
-mod constants;
-mod errors;
+//! Main module for the DML Launcher.
+//!
+//! This module contains the entry point and orchestrates the full lifecycle
+//! of the launcher. It coordinates configuration loading, environment setup,
+//! version management, asset downloading, native extraction, and client launch.
+//!
+//! # Workflow
+//!
+//! 1. Load environment variables from .env.
+//! 2. Initialize logging with the warning level.
+//! 3. Parse command-line arguments using clap.
+//! 4. Load the persistent configuration file.
+//! 5. Apply command-line overrides to configuration values.
+//! 6. Ensure all necessary directories exist.
+//! 7. Load the version manifest for the selected Minecraft version.
+//! 8. Download required assets including libraries and client binaries.
+//! 9. Extract native libraries for the current platform.
+//! 10. Launch the Minecraft client with the configured JVM arguments and
+//!     session information.
+//!
+//! # Error Handling
+//!
+//! All operations that can fail propagate errors through the
+//! McError type. This centralizes error management and
+//! simplifies the use of the ? operator throughout the launcher.
+//!
+//! # Asynchronous Operations
+//!
+//! HTTP requests and asset downloads are performed asynchronously using
+//! tokio to maximize efficiency and reduce blocking. Local file
+//! operations and the client launch remain synchronous to maintain
+//! consistency and avoid race conditions.
 
 mod config;
+mod constants;
+mod errors;
 mod minecraft;
 mod platform;
 mod util;
 
 use clap::Parser;
-use config::Config;
 use dotenvy::dotenv;
 use errors::McError;
-use log::{debug, info};
+use log::LevelFilter::Warn;
+use reqwest::Client;
+use platform::paths::ensure_directories;
 
-use crate::minecraft::{
-    downloads::download_all, extraction::extract_natives, launcher::launch,
-    manifests,
+use crate::{
+    config::ConfigLoader,
+    minecraft::{
+        downloads::download_all_files, extraction::extract_natives, launcher::launch,
+        manifests::load_version,
+    },
 };
+use crate::config::RuntimeConfig;
+use crate::minecraft::manifests::Version;
 
+/// Command-line interface definition.
+///
+/// Provides user-configurable options for the launcher, including
+/// specifying a Minecraft version, a username, and additional
+/// JVM arguments. Utilizes clap for argument parsing and validation.
 #[derive(Parser, Debug)]
 #[command(author, about, disable_version_flag = true)]
 struct Cli {
+    /// Optional Minecraft version to launch.
     #[arg(long)]
     version: Option<String>,
 
+    /// Optional username for the Minecraft session.
     #[arg(long)]
     username: Option<String>,
 
+    /// Optional JVM arguments to pass to the Minecraft process.
+    ///
+    /// Supports multiple values and allows arguments that begin with hyphens.
     #[arg(long, num_args(0..), allow_hyphen_values = true)]
     jvm_args: Vec<String>,
 }
 
+/// Launcher entry point.
+///
+/// This asynchronous function orchestrates the entire launch process,
+/// handling configuration, directory setup, asset management, native
+/// extraction, and client execution. Returns a Result<(), McError>
+/// to capture and propagate all errors encountered during execution.
+///
+/// # Steps
+///
+/// 1. Load environment variables from .env.
+/// 2. Initialize logging with a warning level filter.
+/// 3. Parse CLI arguments and merge them into the configuration.
+/// 4. Ensure required directories exist for game data and assets.
+/// 5. Load the manifest for the specified Minecraft version.
+/// 6. Build an HTTP client with HTTP/2 support for asset downloads.
+/// 7. Download all required assets including libraries and client binaries.
+/// 8. Extract platform-specific native libraries.
+/// 9. Launch the Minecraft client using the configured JVM arguments and
+///    session.
 #[tokio::main]
 async fn main() -> Result<(), McError> {
     dotenv().ok();
-    env_logger::init();
 
-    let cli = Cli::parse();
-    let mut config = Config::load()?;
+    env_logger::Builder::new()
+        .filter_level(Warn)
+        .init();
 
+    let cli: Cli = Cli::parse();
+    let mut config: RuntimeConfig = ConfigLoader::load(None)?; 
+    
     if let Some(v) = cli.version {
         config.version = v;
     }
-
     if let Some(u) = cli.username {
         config.username = u;
     }
@@ -49,16 +118,14 @@ async fn main() -> Result<(), McError> {
         config.jvm_args = cli.jvm_args;
     }
 
-    info!("Final config after CLI overrides: {:?}", config);
-
-    platform::paths::ensure_dirs(&config)?;
-    info!("Using Minecraft version {}", config.version);
+    ensure_directories(&config)?;
 
-    let version = manifests::load_version(&config).await?;
-    info!("Loaded version manifest for: {}", version.id);
-    debug!("Main class: {}", version.main_class);
+    let version: Version = load_version(&config).await?;
+    let client: Client = Client::builder()
+        .http2_prior_knowledge()
+        .build()?;
 
-    download_all(&config, &version).await?;
+    download_all_files(&client, &config, &version).await?;
     extract_natives(&config, &version)?;
     launch(&config, &version)?;
 
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)
 }
diff --git a/src/platform/paths.rs b/src/platform/paths.rs
index b430f09..07313fd 100644
--- a/src/platform/paths.rs
+++ b/src/platform/paths.rs
@@ -1,44 +1,268 @@
 use std::{fs::create_dir_all, path::PathBuf};
 
-use crate::{config::Config, errors::McError};
+use crate::{config::Config, constants::directory, errors::McError};
 
-/// ~/.local/share/dml/minecraft
-pub fn minecraft_root(cfg: &Config) -> PathBuf {
+/// Returns the path to the root Minecraft directory inside the launcher data folder.
+///
+/// This directory acts as the root for all Minecraft-related files within the launcher data.
+/// By default, it joins the `minecraft` directory under the data folder (defined by the launcher).
+///
+/// The returned path does not include any specific assets, versions, or libraries directories.
+/// You can use this as the base path to construct other Minecraft-related paths.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing launcher and Minecraft data folder paths.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the root Minecraft directory.
+pub fn root_directory(cfg: &Config) -> PathBuf {
+    // Remove DEFAULT_LAUNCHER_DIR to avoid duplicate "dml/dml"
     cfg.data_dir.join("minecraft")
 }
 
-pub fn assets_dir(cfg: &Config) -> PathBuf {
-    minecraft_root(cfg).join("assets")
+/// Returns the path to the Minecraft assets directory.
+///
+/// This is where Minecraft assets such as textures, sounds, and other resources are stored.
+/// The assets directory is located inside the root Minecraft directory and can be used
+/// for accessing game assets.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the launcher and Minecraft data.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the assets directory inside the root Minecraft directory.
+pub fn assets_directory(cfg: &Config) -> PathBuf {
+    root_directory(cfg).join(directory::ASSETS)
 }
 
-pub fn game_dir(cfg: &Config) -> PathBuf { minecraft_root(cfg) }
-pub fn ensure_dirs(cfg: &Config) -> Result<(), McError> {
-    let root = minecraft_root(cfg);
-    create_dir_all(&root)?;
-    create_dir_all(root.join("versions"))?;
-    create_dir_all(root.join("libraries"))?;
-    create_dir_all(assets_dir(cfg))?;
-    create_dir_all(assets_dir(cfg).join("indexes"))?;
-    create_dir_all(assets_dir(cfg).join("objects"))?;
-    create_dir_all(root.join("saves"))?;
+/// Returns the path to the game directory (same as root directory for now).
+///
+/// The game directory currently points to the same location as the root directory.
+/// In future iterations, this could be adjusted if game-specific files need to be handled separately.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that holds the paths to the launcher and Minecraft data.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the game directory, which is the same as the root Minecraft directory for now.
+pub fn game_directory(cfg: &Config) -> PathBuf {
+    root_directory(cfg)
+}
+
+/// Ensures that all necessary directories for Minecraft are created.
+///
+/// This function checks if essential directories for Minecraft's file structure exist and creates them
+/// if they do not. This includes directories for versions, libraries, assets, and saves.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the Minecraft data and the required directories.
+///
+/// # Returns
+/// - `Ok(())` if all directories are created successfully.
+/// - `Err(McError)` if an error occurs while creating any directory (such as permission issues).
+///
+/// # Example
+/// ```rust
+/// let cfg = Config { /* configuration values */ };
+/// ensure_directories(&cfg)?;
+/// ```
+///
+/// # Notes
+/// The function creates several directories under the root Minecraft directory, including:
+/// - Root directory
+/// - Versions
+/// - Libraries
+/// - Assets (with subdirectories for `indexes` and `objects`)
+/// - Saves
+///   Each of these directories is essential for managing Minecraft game data and resources.
+pub fn ensure_directories(cfg: &Config) -> Result<(), McError> {
+    let root: PathBuf = root_directory(cfg);
+
+    for dir in [
+        root.clone(),
+        root.join(directory::VERSIONS),
+        root.join(directory::LIBRARIES),
+        assets_directory(cfg),
+        assets_directory(cfg).join(directory::INDEXES),
+        assets_directory(cfg).join(directory::OBJECTS),
+        root.join(directory::SAVES),
+    ] {
+        create_dir_all(dir)?;
+    }
 
     Ok(())
 }
 
+/// Returns the path to a specific version directory inside the root Minecraft directory.
+///
+/// This directory is where the game version-specific files (such as the `.jar` file) are stored.
+/// The path is constructed by joining the `versions` directory with the provided version name.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the directory for the specified version inside the root Minecraft directory.
 pub fn version_dir(cfg: &Config, version: &str) -> PathBuf {
-    minecraft_root(cfg).join("versions").join(version)
+    root_directory(cfg)
+        .join(directory::VERSIONS)
+        .join(version)
 }
 
-pub fn client_jar(cfg: &Config, version: &str) -> Result<PathBuf, McError> {
-    Ok(version_dir(cfg, version).join(format!("{version}.jar")))
+/// Returns the path to the client `.jar` file for a specific Minecraft version.
+///
+/// This file is typically used to run the Minecraft client for a particular version.
+/// The path is constructed by joining the version directory with the name of the `.jar` file.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the `.jar` file for the specified version in the version directory.
+pub fn client_jar(cfg: &Config, version: &str) -> PathBuf {
+    version_dir(cfg, version).join(format!("{version}.jar"))
 }
 
-pub fn library_file(cfg: &Config, rel_path: &str) -> Result<PathBuf, McError> {
-    Ok(minecraft_root(cfg)
-        .join("libraries")
-        .join(rel_path))
+/// Returns the path to a specific library file inside the library directory.
+///
+/// This function is used to access library files required for running Minecraft. The `rel_path`
+/// argument specifies the relative path inside the `libraries` directory. It is useful for handling
+/// dependencies or loading required libraries based on the game version.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) that contains paths for the Minecraft data.
+/// - `rel_path`: The relative path of the library file inside the `libraries` directory.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the specified library file inside the `libraries` directory.
+pub fn library_file(cfg: &Config, rel_path: &str) -> PathBuf {
+    root_directory(cfg)
+        .join(directory::LIBRARIES)
+        .join(rel_path)
 }
 
+/// Returns the path to the natives directory for a specific Minecraft version.
+///
+/// The natives directory contains platform-specific native libraries (e.g., `.dll`, `.so`, `.dylib`)
+/// that Minecraft uses to run the game. This function returns the path to the directory for the
+/// specified version.
+///
+/// # Parameters
+/// - `cfg`: The configuration object (`Config`) containing paths for the Minecraft data.
+/// - `version`: The version of Minecraft (e.g., "1.18.2") to generate the path for.
+///
+/// # Returns
+/// - A `PathBuf` pointing to the natives directory for the specified version.
 pub fn natives_dir(cfg: &Config, version: &str) -> PathBuf {
-    version_dir(cfg, version).join("natives")
+    version_dir(cfg, version).join(directory::NATIVES)
+}
+
+// /// Path to a version’s saves directory.
+// pub fn saves_dir(cfg: &Config) -> PathBuf {
+//     minecraft_root(cfg).join(dirs::SAVES)
+// }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::Path;
+
+    fn test_config(tmp: &Path) -> Config {
+        Config {
+            data_dir: tmp.to_path_buf(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn root_directory_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let root = root_directory(&cfg);
+        assert_eq!(root, tmp.path().join("minecraft"));
+    }
+
+    #[test]
+    fn assets_directory_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let assets = assets_directory(&cfg);
+        assert_eq!(assets, root_directory(&cfg).join(directory::ASSETS));
+    }
+
+    #[test]
+    fn version_paths_are_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let version = "1.20.1";
+        assert_eq!(
+            version_dir(&cfg, version),
+            root_directory(&cfg)
+                .join(directory::VERSIONS)
+                .join(version)
+        );
+
+        assert_eq!(
+            client_jar(&cfg, version),
+            version_dir(&cfg, version).join("1.20.1.jar")
+        );
+    }
+
+    #[test]
+    fn library_file_path_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let rel = "com/example/lib.jar";
+        assert_eq!(
+            library_file(&cfg, rel),
+            root_directory(&cfg)
+                .join(directory::LIBRARIES)
+                .join(rel)
+        );
+    }
+
+    #[test]
+    fn natives_dir_path_is_correct() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        let version = "1.20.1";
+        assert_eq!(
+            natives_dir(&cfg, version),
+            version_dir(&cfg, version).join(directory::NATIVES)
+        );
+    }
+
+    #[test]
+    fn ensure_directories_creates_structure() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cfg = test_config(tmp.path());
+
+        ensure_directories(&cfg).unwrap();
+
+        let root = root_directory(&cfg);
+
+        let expected_dirs = [
+            root.clone(),
+            root.join(directory::VERSIONS),
+            root.join(directory::LIBRARIES),
+            root.join(directory::ASSETS),
+            root.join(directory::ASSETS)
+                .join(directory::INDEXES),
+            root.join(directory::ASSETS)
+                .join(directory::OBJECTS),
+            root.join(directory::SAVES),
+        ];
+
+        for dir in expected_dirs {
+            assert!(dir.exists(), "Missing directory: {:?}", dir);
+            assert!(dir.is_dir());
+        }
+    }
 }
diff --git a/src/util/fs.rs b/src/util/fs.rs
index 8ecd0d0..b1e9152 100644
--- a/src/util/fs.rs
+++ b/src/util/fs.rs
@@ -4,7 +4,10 @@ use std::path::Path;
 
 use tokio::fs::remove_file;
 
-use crate::errors::McError;
+use crate::{
+    errors::McError,
+    minecraft::manifests::{Library, Rule},
+};
 
 pub async fn remove_if_exists(path: &Path) -> Result<(), McError> {
     if path.exists() {
@@ -12,3 +15,24 @@ pub async fn remove_if_exists(path: &Path) -> Result<(), McError> {
     }
     Ok(())
 }
+
+pub fn library_allowed(lib: &Library) -> bool {
+    let rules: &Vec<Rule> = match &lib.rules {
+        | Some(r) => r,
+        | None => return true,
+    };
+
+    let mut allowed: bool = false;
+
+    for rule in rules {
+        let os_match: bool = match &rule.os {
+            | Some(os) => os.name == "linux",
+            | None => true,
+        };
+        if os_match {
+            allowed = rule.action == "allow";
+        }
+    }
+
+    allowed
+}
diff --git a/src/util/sha1.rs b/src/util/sha1.rs
index 6684963..6fed18d 100644
--- a/src/util/sha1.rs
+++ b/src/util/sha1.rs
@@ -2,14 +2,15 @@
 
 use std::path::Path;
 
-use sha1::{Digest, Sha1};
+use sha1::{Digest, Sha1, Sha1Core};
+use sha1::digest::core_api::CoreWrapper;
 use tokio::fs::read;
 
 use crate::errors::McError;
 
 pub async fn sha1_hex(path: &Path) -> Result<String, McError> {
-    let data = read(path).await?;
-    let mut hasher = Sha1::new();
+    let data: Vec<u8> = read(path).await?;
+    let mut hasher: CoreWrapper<Sha1Core> = Sha1::new();
     hasher.update(&data);
     Ok(format!("{:x}", hasher.finalize()))
 }