Minecraft Launcher Lib

https://minecraft-launcher-lib.readthedocs.io/en/stable/
Admin
Minecraft Launcher Lib is an easy-to-use Python library for creating your own Minecraft Launcher.
Tokens:29,384
Snippets:350
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Managing Installation Threads in PyQt

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/PyQtInstallation.rst.txt

Disables installation buttons and starts a background thread to prevent the GUI from freezing during the installation process.

```python
# This is more complex than using the same Thread, but the GUI will not freeze
self._install_single_thread_button.setEnabled(False)
self._install_multi_thread_button.setEnabled(False)

self._install_thread.set_data(self._version_combo_box.currentText(), self._path_edit.text())
self._install_thread.start()
```

--------------------------------

### Minecraft Installation with PyQt

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/PyQtInstallation.rst.txt

A full implementation of a PyQt window that allows users to select a Minecraft version and installation path, featuring both blocking and non-blocking installation methods.

```python
#!/usr/bin/env python3
# This example shows how to install Minecraft with a ProgressBar in PyQt
from PyQt6.QtWidgets import QApplication, QWidget, QLabel, QComboBox, QLineEdit, QPushButton, QProgressBar, QFileDialog, QFormLayout, QHBoxLayout, QVBoxLayout
from PyQt6.QtCore import QThread, pyqtSignal
import minecraft_launcher_lib
import sys


class InstallThread(QThread):
    progress_max = pyqtSignal("int")
    progress = pyqtSignal("int")
    text = pyqtSignal("QString")

    def __init__(self) -> None:
        QThread.__init__(self)
        self._callback_dict = {
            "setStatus": lambda text: self.text.emit(text),
            "setMax": lambda max_progress: self.progress_max.emit(max_progress),
            "setProgress": lambda progress: self.progress.emit(progress),
        }

    def set_data(self, version: str, directory) -> None:
        self._version = version
        self._directory = directory

    def run(self) -> None:
        minecraft_launcher_lib.install.install_minecraft_version(self._version, self._directory, callback=self._callback_dict)


class Window(QWidget):
    def __init__(self) -> None:
        super().__init__()

        self._install_thread = InstallThread()

        self._version_combo_box = QComboBox()
        self._path_edit = QLineEdit()
        self._path_browse_button = QPushButton("Browse")
        self._progress_bar = QProgressBar()
        self._install_single_thread_button = QPushButton("Install Single Thread")
        self._install_multi_thread_button = QPushButton("Install Multi Thread")

        for i in minecraft_launcher_lib.utils.get_version_list():
            self._version_combo_box.addItem(i["id"])

        self._path_edit.setText(minecraft_launcher_lib.utils.get_minecraft_directory())

        self._progress_bar.setTextVisible(True)

        self._install_thread.progress_max.connect(lambda maximum: self._progress_bar.setMaximum(maximum))
        self._install_thread.progress.connect(lambda value: self._progress_bar.setValue(value))
        self._install_thread.text.connect(lambda text: self._progress_bar.setFormat(text))
        self._install_thread.finished.connect(self._install_thread_finished)

        self._path_browse_button.clicked.connect(self._path_browse_button_clicked)
        self._install_single_thread_button.clicked.connect(self._install_minecraft_single_thread)
        self._install_multi_thread_button.clicked.connect(self._install_minecraft_multi_thread)

        path_layout = QHBoxLayout()
        path_layout.addWidget(self._path_edit)
        path_layout.addWidget(self._path_browse_button)

        form_layout = QFormLayout()
        form_layout.addRow(QLabel("Version:"), self._version_combo_box)
        form_layout.addRow(QLabel("Path:"), path_layout)

        button_layout = QHBoxLayout()
        button_layout.addWidget(self._install_single_thread_button)
        button_layout.addWidget(self._install_multi_thread_button)

        main_layout = QVBoxLayout()
        main_layout.addLayout(form_layout)
        main_layout.addWidget(self._progress_bar)
        main_layout.addLayout(button_layout)

        self.setLayout(main_layout)
        self.setWindowTitle("PyQtInstallation")

    def _install_thread_finished(self) -> None:
        # This function is called after the Multi Thread Installation has been finished
        self._install_single_thread_button.setEnabled(True)
        self._install_multi_thread_button.setEnabled(True)

    def _path_browse_button_clicked(self) -> None:
        path = QFileDialog.getExistingDirectory(self, directory=self._path_edit.text())
        if path != "":
            self._path_edit.setText(path)

    def _install_minecraft_single_thread(self) -> None:
        # This function installs Minecraft in the same Thread as the GUI
        # This is much simpler than using a other Thread, but the GUI will freeze until the function is completed
        callback = {
            "setStatus": lambda text: self._progress_bar.setFormat(text),
            "setProgress": lambda value: self._progress_bar.setValue(value),
            "setMax": lambda maximum: self._progress_bar.setMaximum(maximum)
        }

        minecraft_launcher_lib.install.install_minecraft_version(self._version_combo_box.currentText(), self._path_edit.text(), callback=callback)

    def _install_minecraft_multi_thread(self) -> None:
        # This functions installs Minecraft on a other Thread than the GUI
```

--------------------------------

### Install via pip

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/installation.rst.txt

The standard method for installing the library from PyPI.

```shell
pip install -U minecraft-launcher-lib
```

--------------------------------

### Display Installation Progress in Python

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/InstallationProgress.rst.txt

Uses a callback dictionary to hook into the installation process, updating a terminal progress bar as files are downloaded and installed.

```python
#!/usr/bin/env python3
# This example shows how to show the progress of installation to the user.
import minecraft_launcher_lib


# Taken from https://stackoverflow.com/questions/3173320/text-progress-bar-in-the-console
def printProgressBar(iteration, total, prefix='', suffix='', decimals=1, length=100, fill='█', printEnd="\r"):
    """
    Call in a loop to create terminal progress bar
    @params:
        iteration   - Required  : current iteration (Int)
        total       - Required  : total iterations (Int)
        prefix      - Optional  : prefix string (Str)
        suffix      - Optional  : suffix string (Str)
        decimals    - Optional  : positive number of decimals in percent complete (Int)
        length      - Optional  : character length of bar (Int)
        fill        - Optional  : bar fill character (Str)
        printEnd    - Optional  : end character (e.g. "\r", "\r\n") (Str)
    """
    percent = ("{0:." + str(decimals) + "f}").format(100 * (iteration / float(total)))
    filledLength = int(length * iteration // total)
    bar = fill * filledLength + '-' * (length - filledLength)
    print('\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix), end=printEnd)
    # Print New Line on Complete
    if iteration == total:
        print()


def maximum(max_value, value):
    max_value[0] = value


def main():
    # lambda doesn't allow setting vars, so we need this little hack
    max_value = [0]

    callback = {
        "setStatus": lambda text: print(text),
        "setProgress": lambda value: printProgressBar(value, max_value[0]),
        "setMax": lambda value: maximum(max_value, value)
    }

    version = minecraft_launcher_lib.utils.get_latest_version()["release"]
    directory = minecraft_launcher_lib.utils.get_minecraft_directory()

    minecraft_launcher_lib.install.install_minecraft_version(version, directory, callback=callback)


if __name__ == "__main__":
    main()
```

--------------------------------

### Install Sphinx and theme

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/develop/build_and_edit_documentation.rst.txt

Install the necessary dependencies to build the documentation locally.

```bash
pip install sphinx sphinx-rtd-theme
```

--------------------------------

### Minecraft Installation with PyQt6 GUI

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/examples/PyQtInstallation.html

A full implementation of a PyQt6 window that allows users to select a Minecraft version and installation path, featuring both blocking and non-blocking installation methods.

```python
#!/usr/bin/env python3
# This example shows how to install Minecraft with a ProgressBar in PyQt
from PyQt6.QtWidgets import QApplication, QWidget, QLabel, QComboBox, QLineEdit, QPushButton, QProgressBar, QFileDialog, QFormLayout, QHBoxLayout, QVBoxLayout
from PyQt6.QtCore import QThread, pyqtSignal
import minecraft_launcher_lib
import sys


class InstallThread(QThread):
    progress_max = pyqtSignal("int")
    progress = pyqtSignal("int")
    text = pyqtSignal("QString")

    def __init__(self) -> None:
        QThread.__init__(self)
        self._callback_dict = {
            "setStatus": lambda text: self.text.emit(text),
            "setMax": lambda max_progress: self.progress_max.emit(max_progress),
            "setProgress": lambda progress: self.progress.emit(progress),
        }

    def set_data(self, version: str, directory) -> None:
        self._version = version
        self._directory = directory

    def run(self) -> None:
        minecraft_launcher_lib.install.install_minecraft_version(self._version, self._directory, callback=self._callback_dict)


class Window(QWidget):
    def __init__(self) -> None:
        super().__init__()

        self._install_thread = InstallThread()

        self._version_combo_box = QComboBox()
        self._path_edit = QLineEdit()
        self._path_browse_button = QPushButton("Browse")
        self._progress_bar = QProgressBar()
        self._install_single_thread_button = QPushButton("Install Single Thread")
        self._install_multi_thread_button = QPushButton("Install Multi Thread")

        for i in minecraft_launcher_lib.utils.get_version_list():
            self._version_combo_box.addItem(i["id"])

        self._path_edit.setText(minecraft_launcher_lib.utils.get_minecraft_directory())

        self._progress_bar.setTextVisible(True)

        self._install_thread.progress_max.connect(lambda maximum: self._progress_bar.setMaximum(maximum))
        self._install_thread.progress.connect(lambda value: self._progress_bar.setValue(value))
        self._install_thread.text.connect(lambda text: self._progress_bar.setFormat(text))
        self._install_thread.finished.connect(self._install_thread_finished)

        self._path_browse_button.clicked.connect(self._path_browse_button_clicked)
        self._install_single_thread_button.clicked.connect(self._install_minecraft_single_thread)
        self._install_multi_thread_button.clicked.connect(self._install_minecraft_multi_thread)

        path_layout = QHBoxLayout()
        path_layout.addWidget(self._path_edit)
        path_layout.addWidget(self._path_browse_button)

        form_layout = QFormLayout()
        form_layout.addRow(QLabel("Version:"), self._version_combo_box)
        form_layout.addRow(QLabel("Path:"), path_layout)

        button_layout = QHBoxLayout()
        button_layout.addWidget(self._install_single_thread_button)
        button_layout.addWidget(self._install_multi_thread_button)

        main_layout = QVBoxLayout()
        main_layout.addLayout(form_layout)
        main_layout.addWidget(self._progress_bar)
        main_layout.addLayout(button_layout)

        self.setLayout(main_layout)
        self.setWindowTitle("PyQtInstallation")

    def _install_thread_finished(self) -> None:
        # This function is called after the Multi Thread Installation has been finished
        self._install_single_thread_button.setEnabled(True)
        self._install_multi_thread_button.setEnabled(True)

    def _path_browse_button_clicked(self) -> None:
        path = QFileDialog.getExistingDirectory(self, directory=self._path_edit.text())
        if path != "":
            self._path_edit.setText(path)

    def _install_minecraft_single_thread(self) -> None:
        # This function installs Minecraft in the same Thread as the GUI
        # This is much simpler than using a other Thread, but the GUI will freeze until the function is completed
        callback = {
            "setStatus": lambda text: self._progress_bar.setFormat(text),
            "setProgress": lambda value: self._progress_bar.setValue(value),
            "setMax": lambda maximum: self._progress_bar.setMaximum(maximum)
        }

        minecraft_launcher_lib.install.install_minecraft_version(self._version_combo_box.currentText(), self._path_edit.text(), callback=callback)

    def _install_minecraft_multi_thread(self) -> None:
        # This functions installs Minecraft on a other Thread than the GUI
        # This is more complex than using the same Thread, but the GUI will not freeze
        self._install_single_thread_button.setEnabled(False)
        self._install_multi_thread_button.setEnabled(False)

        self._install_thread.set_data(self._version_combo_box.currentText(), self._path_edit.text())
        self._install_thread.start()


def main():
    app = QApplication(sys.argv)

    w = Window()
    w.show()

    sys.exit(app.exec())


if __name__ == "__main__":
    main()
```

--------------------------------

### Implement Installation Progress Callbacks

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/tutorial/get_installation_progress.rst.txt

Define custom functions for status, progress, and maximum value updates, then pass them as a dictionary to the installation method.

```python
import minecraft_launcher_lib


current_max = 0


def set_status(status: str):
    print(status)


def set_progress(progress: int):
    if current_max != 0:
        print(f"{progress}/{current_max}")


def set_max(new_max: int):
    global current_max
    current_max = new_max


minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()

callback = {
    "setStatus": set_status,
    "setProgress": set_progress,
    "setMax": set_max
}

minecraft_launcher_lib.install.install_minecraft_version("1.17", minecraft_directory, callback=callback)
```

--------------------------------

### Install from source

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/installation.rst.txt

Installs the latest development version directly from the source repository. Use this only if necessary to access unreleased changes.

```shell
pip install -U git+https://codeberg.org/JakobDev/minecraft-launcher-lib.git
```

--------------------------------

### Install and Launch Mod Loader

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/ModLoader.rst.txt

Demonstrates the full workflow of listing available mod loaders, selecting a Minecraft version, installing the loader, and launching the game.

```python
#!/usr/bin/env python3
# This example shows how use the mod loader module
import minecraft_launcher_lib
import subprocess


def choose(options: list[str]) -> int:
    for pos, text in enumerate(options):
        print(f"{pos + 1}: {text}")

    while True:
        try:
            answer = int(input(f"Select[1-{len(options)}]:")) - 1
            if answer >= 0 and answer < len(options):
                return answer
        except ValueError:
            pass


def ask_yes_no(text: str) -> bool:
    while True:
        answer = input(f"{text}[y/n]:").strip().upper()

        if answer == "Y":
            return True
        elif answer == "N":
            return False
        else:
            print("Invalid answer. Use y or n.")


def main() -> None:
    id_list = minecraft_launcher_lib.mod_loader.list_mod_loader()

    name_list = []
    for current_id in id_list:
        name_list.append(minecraft_launcher_lib.mod_loader.get_mod_loader(current_id).get_name())

    print("Please select a mod loader:")

    loader = minecraft_launcher_lib.mod_loader.get_mod_loader(id_list[choose(name_list)])
    version_list = loader.get_minecraft_versions(True)

    print()
    print("Please select the Minecraft version for which you want to install the mod loader.")
    vanilla_version = version_list[choose(version_list)]

    print()
    minecraft_directory = input("Enter the path to your Minecraft directory (leave blank for default):").strip()
    if minecraft_directory == "":
        minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()

    installed_version = loader.install(vanilla_version, minecraft_directory, callback={"setStatus": print})

    print("Finished")

    if not ask_yes_no("Do you want to launch Minecraft?"):
        return

    command = minecraft_launcher_lib.command.get_minecraft_command(installed_version, minecraft_directory, minecraft_launcher_lib.utils.generate_test_options())
    subprocess.run(command, cwd=minecraft_directory)


if __name__ == "__main__":
    main()
```

--------------------------------

### Get Installed Minecraft Versions

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Retrieves a list of all versions currently installed in the specified directory.

```python
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
for version in minecraft_launcher_lib.utils.get_installed_versions(minecraft_directory):
    print(version["id"])
```

--------------------------------

### Get latest Fabric installer version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/fabric.html

Prints the latest available Fabric installer version.

```python
print("Latest installer version: " + minecraft_launcher_lib.fabric.get_latest_installer_version())
```

--------------------------------

### install(minecraft_version, minecraft_directory, *, loader_version, callback, java)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/mod_loader.html

Installs the mod loader for a specified vanilla Minecraft version.

```APIDOC
### Method
`install(minecraft_version: str, minecraft_directory: str | PathLike, *, loader_version: str | None = None, callback: CallbackDict | None = None, java: str | PathLike | None = None) -> str`

### Description
Installs the mod loader for the given vanilla version. If the vanilla version is not installed, it will be installed automatically.

### Parameters
- **minecraft_version** (str) - The vanilla Minecraft version.
- **minecraft_directory** (str | PathLike) - The path to your Minecraft directory.
- **loader_version** (str | None) - The version of the mod loader. If not set, the latest one is used.
- **callback** (CallbackDict | None) - Optional callback for installation progress.
- **java** (str | PathLike | None) - Path to the Java executable to use during installation.

### Returns
- **str** - The installed version string.
```

--------------------------------

### Install and Launch Minecraft

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/SimpleLaunch.rst.txt

This script handles the full flow of installing the latest Minecraft version, performing Microsoft account authentication, and executing the launch command.

```python
#!/usr/bin/env python3
# This example shows how to simple install and launch the latest version of Minecraft.
import minecraft_launcher_lib
import subprocess
import sys

# Set the data for your Azure Application here. For more information look at the documentation.
CLIENT_ID = "YOUR CLIENT ID"
REDIRECT_URL = "YOUR REDIRECT URL"

# Get latest version
latest_version = minecraft_launcher_lib.utils.get_latest_version()["release"]

# Get Minecraft directory
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()

# Make sure, the latest version of Minecraft is installed
minecraft_launcher_lib.install.install_minecraft_version(latest_version, minecraft_directory)

# Login
login_url, state, code_verifier = minecraft_launcher_lib.microsoft_account.get_secure_login_data(CLIENT_ID, REDIRECT_URL)
print(f"Please open {login_url} in your browser and copy the url you are redirected into the prompt below.")
code_url = input()

# Get the code from the url
try:
    auth_code = minecraft_launcher_lib.microsoft_account.parse_auth_code_url(code_url, state)
except AssertionError:
    print("States do not match!")
    sys.exit(1)
except KeyError:
    print("Url not valid")
    sys.exit(1)

# Get the login data
login_data = minecraft_launcher_lib.microsoft_account.complete_login(CLIENT_ID, None, REDIRECT_URL, auth_code, code_verifier)

# Get Minecraft command
options = {
    "username": login_data["name"],
    "uuid": login_data["id"],
    "token": login_data["access_token"]
}
minecraft_command = minecraft_launcher_lib.command.get_minecraft_command(latest_version, minecraft_directory, options)

# Start Minecraft
subprocess.run(minecraft_command, cwd=minecraft_directory)
```

--------------------------------

### Install a JVM runtime

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/runtime.html

Installs a specific JVM version into the Minecraft directory.

```python
runtime_version = "java-runtime-gamma"
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
minecraft_launcher_lib.runtime.install_jvm_runtime(runtime_version, minecraft_directory)
```

--------------------------------

### Install mypy and dependencies

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/develop/static_typing.rst.txt

Install the required type checking tools and type stubs for the requests library.

```shell
pip install requests types-requests mypy
```

--------------------------------

### Install test dependencies

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/develop/automatic_tests.rst.txt

Install the required packages for running tests using the provided requirements file.

```shell
pip install -r requirements-test.txt
```

--------------------------------

### Install a Modpack

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/mrpack.html

Installs a .mrpack file into the specified Minecraft directory.

```python
path = "/path/to/mrpack"
minecraft_directory = minecraft_directory.utils.get_minecraft_directory()
minecraft_launcher_lib.mrpack.install_mrpack(path, minecraft_directory)
```

--------------------------------

### Get latest Quilt installer version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/quilt.html

Retrieves the latest available Quilt installer version.

```python
print("Latest installer version: " + minecraft_launcher_lib.quilt.get_latest_installer_version())
```

--------------------------------

### Configure Mrpack Installation Options

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/mrpack.html

Defines the dictionary structure for optional installation settings, such as handling optional files or skipping dependency installation.

```python
mrpack_install_options = {
    "optionalFiles": [], # List with all Optional files
    "skipDependenciesInstall": False # If you want to skip the Dependencies install. Only used for testing purposes.
}
```

--------------------------------

### run_forge_installer(version, java=None)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/forge.html

Executes the Forge installer for a specific version.

```APIDOC
## run_forge_installer(version, java=None)

### Description
Run the forge installer of the given forge version.

### Parameters
- **version** (str) - Required - A Forge Version identifier.
- **java** (str | PathLike | None) - Optional - Path to a custom Java executable.

### Returns
- **None**
```

--------------------------------

### Install Minecraft Version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/tutorial/getting_started.rst.txt

Install a specific version of Minecraft into the designated directory.

```python
minecraft_launcher_lib.install.install_minecraft_version("1.17", minecraft_directory)
```

--------------------------------

### install_jvm_runtime(jvm_version, minecraft_directory, callback=None, max_workers=None)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/runtime.html

Installs the specified JVM runtime into the Minecraft directory.

```APIDOC
## install_jvm_runtime(jvm_version, minecraft_directory, callback=None, max_workers=None)

### Description
Installs the given JVM runtime.

### Parameters
- **jvm_version** (str) - Required - The name of the JVM version.
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.
- **callback** (CallbackDict | None) - Optional - Callback dictionary for progress tracking.
- **max_workers** (int | None) - Optional - Number of workers for asynchronous downloads.

### Raises
- **VersionNotFound** - The given JVM Version was not found.
- **FileOutsideMinecraftDirectory** - A file should be placed outside the given Minecraft directory.
```

--------------------------------

### Get Available Minecraft Versions

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Retrieves a list containing both installed versions and versions available for download.

```python
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
for version in minecraft_launcher_lib.utils.get_available_versions(minecraft_directory):
    print(version["id"])
```

--------------------------------

### Install Style Checking Tools

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/develop/codestyle.rst.txt

Install the required flake8 packages to enable automated style, annotation, and docstring validation.

```shell
pip install flake8 flake8-annotation flake8-docstring-checker flake8-assert-finder
```

--------------------------------

### Install and Launch a .mrpack File

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/Mrpack.rst.txt

A comprehensive script that prompts for a .mrpack file, handles optional file selection, installs the modpack, and launches the game.

```python
#!/usr/bin/env python3
# This example shows how use the mrpack module
import minecraft_launcher_lib
import subprocess
import sys
import os


def ask_yes_no(text: str) -> bool:
    while True:
        answer = input(f"{text} [Y/N]: ").strip().upper()

        if answer == "Y":
            return True
        elif answer == "N":
            return False
        else:
            print("Invalid answer. Use Y or N.")


def main() -> None:
    mrpack_path = input("Please enter the Path to your .mrpack File: ")

    if not os.path.isfile(mrpack_path):
        print(f"{mrpack_path} was not found", file=sys.stderr)
        sys.exit(1)

    try:
        mrpack_information = minecraft_launcher_lib.mrpack.get_mrpack_information(mrpack_path)
    except Exception:
        print(f"{mrpack_path} is not a valid .mrpack File")
        sys.exit(1)

    # Print some Information
    print("You have selected the following Pack:")
    print("Name: " + mrpack_information["name"])
    print("Summary: " + mrpack_information["summary"])
    print("Minecraft version: " + mrpack_information["minecraftVersion"])

    if not ask_yes_no("Do you want to install this Pack?"):
        return

    # Ask the User for the Directories
    minecraft_directory = input("Please enter the Path to your Minecraft directory (leave empty for default): ")

    if minecraft_directory == "":
        minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()

    modpack_directory = input("Please enter the Path to the Directory you want to install the Modpack (leave empty for your Minecraft directory): ")

    if modpack_directory == "":
        modpack_directory = minecraft_directory

    # Adds the Optional Files
    mrpack_install_options: minecraft_launcher_lib.types.MrpackInstallOptions = {"optionalFiles": []}
    for i in mrpack_information["optionalFiles"]:
        if ask_yes_no(f"The Pack includes the Optional File {i}. Do you want to install it?"):
            mrpack_install_options["optionalFiles"].append(i)

    # Install
    print("Installing")
    minecraft_launcher_lib.mrpack.install_mrpack(mrpack_path, minecraft_directory, modpack_directory=modpack_directory, mrpack_install_options=mrpack_install_options, callback={"setStatus": print})
    print("Finished")

    if not ask_yes_no("Do you want to start Minecraft?"):
        return

    # We skip the Login in this Example
    options = minecraft_launcher_lib.utils.generate_test_options()
    options["gameDirectory"] = modpack_directory
    command = minecraft_launcher_lib.command.get_minecraft_command(minecraft_launcher_lib.mrpack.get_mrpack_launch_version(mrpack_path), minecraft_directory, options)
    subprocess.run(command)


if __name__ == "__main__":
    main()
```

--------------------------------

### Define Callback Dictionary

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/install.html

Structure for the callback parameter to monitor installation progress.

```python
callback = {
    "setStatus": some_function, # This function is called to set a text
    "setProgress" some_function, # This function is called to set the progress.
    "setMax": some_function, # This function is called to set to max progress.
}
```

--------------------------------

### Retrieve Java installation information

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/java_utils.html

Use get_java_information to extract details like version and name from a specific Java installation path. The path provided must be the root directory of the installation.

```python
java_path = "<path>"
information = minecraft_launcher_lib.java_utils.get_java_information(java_path)
print("Name: " + information["name"])
print("Version: " + information["version"])
print("Java path: " + information["java_path"])
```

--------------------------------

### Install Quilt modloader

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/quilt.html

Installs the Quilt modloader into the specified Minecraft directory.

```python
minecraft_version = "1.20"
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
minecraft_launcher_lib.quilt.install_quilt(minecraft_version, minecraft_directory)
```

--------------------------------

### install_minecraft_version(version, minecraft_directory, callback=None)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/install.html

Installs a specific Minecraft version to a target directory. This function also performs verification and repairs on existing installations, ensuring only missing or corrupted files are downloaded.

```APIDOC
## install_minecraft_version(version, minecraft_directory, callback=None)

### Description
Installs a Minecraft version to the specified path. It also verifies and repairs an existing installation, so call it before launching. Only missing or corrupted files will be downloaded.

### Parameters
- **version** (str) - The Minecraft version to install.
- **minecraft_directory** (str | PathLike) - The path to your Minecraft directory.
- **callback** (CallbackDict | None) - Optional dictionary containing functions to monitor progress (setStatus, setProgress, setMax).

### Raises
- **VersionNotFound** - The specified Minecraft version was not found.
- **FileOutsideMinecraftDirectory** - A file should be placed outside the given Minecraft directory.

### Example
```python
import minecraft_launcher_lib
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
minecraft_launcher_lib.install.install_minecraft_version("1.21", minecraft_directory)
```
```

--------------------------------

### Install a Mod Loader for a specific version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/tutorial/install_mod_loader.rst.txt

Execute the install method on the loader object, providing the target Minecraft version and the directory path.

```python
fabric.install("1.21", minecraft_directory)
```

--------------------------------

### Execute Minecraft Command

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/command.html

Example of generating a launch command and executing it using the subprocess module.

```python
options = minecraft_launcher_lib.utils.generate_test_options()
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
command = minecraft_launcher_lib.command.get_minecraft_command("1.21", minecraft_directory, options)
subprocess.run(command, pwd=minecraft_directory)
```

--------------------------------

### get_available_versions(minecraft_directory)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Returns all installed versions and all versions that Mojang offers to download.

```APIDOC
## get_available_versions(minecraft_directory)

### Description
Returns all installed versions and all versions that Mojang offers to download.

### Parameters
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.

### Returns
- **list[MinecraftVersionInfo]** - A list of all available Minecraft versions.
```

--------------------------------

### install_fabric(minecraft_version, minecraft_directory, ...)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/fabric.html

Installs the Fabric modloader into the specified directory.

```APIDOC
## install_fabric(minecraft_version, minecraft_directory, loader_version=None, callback=None, java=None)

### Description
Installs the Fabric modloader for a specific Minecraft version.

### Parameters
- **minecraft_version** (str) - Required - A vanilla version supported by Fabric.
- **minecraft_directory** (str | PathLike) - Required - The path to the Minecraft directory.
- **loader_version** (str | None) - Optional - The Fabric loader version to use.
- **callback** (CallbackDict | None) - Optional - Callback dictionary for progress tracking.
- **java** (str | PathLike | None) - Optional - Path to a custom Java executable.

### Exceptions
- **VersionNotFound** - If the Minecraft version does not exist.
- **UnsupportedVersion** - If the Minecraft version is not supported by Fabric.
```

--------------------------------

### install_quilt(minecraft_version, minecraft_directory, ...)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/quilt.html

Installs the Quilt modloader into the specified directory.

```APIDOC
## install_quilt(minecraft_version, minecraft_directory, loader_version=None, callback=None, java=None)

### Description
Installs the Quilt modloader.

### Parameters
- **minecraft_version** (str) - Required - A vanilla version that is supported by Quilt.
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.
- **loader_version** (str | None) - Optional - The Quilt loader version. If not given it will use the latest.
- **callback** (CallbackDict | None) - Optional - The same dict as for install_minecraft_version().
- **java** (str | PathLike | None) - Optional - A Path to a custom Java executable.

### Errors
- **VersionNotFound** - The given Minecraft does not exist.
- **UnsupportedVersion** - The given Minecraft version is not supported by Quilt.
```

--------------------------------

### get_installed_versions(minecraft_directory)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Returns all installed versions in the specified directory.

```APIDOC
## get_installed_versions(minecraft_directory)

### Description
Returns all installed versions.

### Parameters
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.

### Returns
- **list[MinecraftVersionInfo]** - A list of installed Minecraft versions.
```

--------------------------------

### Check for Minecraft installation

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Verifies if a valid Minecraft installation exists within the specified directory.

```python
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
if minecraft_launcher_lib.utils.is_minecraft_installed(minecraft_directory):
    print("Minecraft is installed")
else:
    print("Minecraft is not installed")
```

--------------------------------

### Install Fabric modloader

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/fabric.html

Installs the Fabric modloader for a specific Minecraft version into the designated directory.

```python
minecraft_version = "1.20"
minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
minecraft_launcher_lib.fabric.install_fabric(minecraft_version, minecraft_directory)
```

--------------------------------

### List installed JVM runtimes

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/runtime.html

Retrieves a list of all JVM runtimes currently installed in the specified directory.

```python
for runtime in minecraft_launcher_lib.runtime.get_installed_jvm_runtimes():
    print(runtime)
```

--------------------------------

### Get Library Version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Returns the current version of the minecraft-launcher-lib library.

```python
print(f"You are using version {minecraft_launcher_lib.utils.get_library_version()} of minecraft-launcher-lib")
```

--------------------------------

### get_installed_jvm_runtimes(minecraft_directory)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/runtime.html

Returns a list of all installed JVM runtimes within the specified directory.

```APIDOC
## get_installed_jvm_runtimes(minecraft_directory)

### Description
Returns a list of all installed JVM runtimes.

### Parameters
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.

### Returns
- **list[str]** - A list of installed JVM runtime names.
```

--------------------------------

### install_forge_version(versionid, path, callback=None, java=None)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/forge.html

Installs a specific Forge version into the provided Minecraft directory.

```APIDOC
## install_forge_version(versionid, path, callback=None, java=None)

### Description
Installs the given Forge version into the specified Minecraft directory.

### Parameters
- **versionid** (str) - Required - A Forge Version identifier.
- **path** (str | PathLike) - Required - The path to your Minecraft directory.
- **callback** (CallbackDict | None) - Optional - Callback dictionary for installation progress.
- **java** (str | PathLike | None) - Optional - Path to a custom Java executable.

### Returns
- **None**

### Raises
- **VersionNotFound** - If the specified forge version is not found.
```

--------------------------------

### get_latest_installer_version()

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/fabric.html

Returns the latest Fabric installer version.

```APIDOC
## get_latest_installer_version()

### Description
Retrieves the latest available Fabric installer version.

### Returns
- **str** - The latest installer version string.
```

--------------------------------

### install_mrpack(path, minecraft_directory, modpack_directory, callback, mrpack_install_options)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/mrpack.html

Installs a .mrpack file into the specified Minecraft directory.

```APIDOC
## install_mrpack(path, minecraft_directory, modpack_directory, callback, mrpack_install_options)

### Description
Installs a .mrpack file. Allows for optional configuration of installation paths and options.

### Parameters
- **path** (str | PathLike) - Required - The path to the .mrpack file.
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.
- **modpack_directory** (str | PathLike | None) - Optional - Custom directory for modpack installation.
- **callback** (CallbackDict | None) - Optional - Callback dictionary for installation progress.
- **mrpack_install_options** (MrpackInstallOptions | None) - Optional - Options for installing the pack (e.g., optionalFiles, skipDependenciesInstall).

### Raises
- **FileOutsideMinecraftDirectory** - Raised if a file is placed outside the given Minecraft directory.
```

--------------------------------

### Find system Java versions with information

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/java_utils.html

Use find_system_java_versions_information to retrieve detailed information about all discovered Java installations. This function executes the Java executable for each installation found.

```python
for version_information in minecraft_launcher_lib.java_utils.find_system_java_versions_information():
    print("Path: " + version_information["path"])
    print("Name: " + version_information["name"])
    print("Version: " + version_information["version"])
    print("Java path: " + version_information["java_path"])
    print()
```

--------------------------------

### find_system_java_versions(additional_directories)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/java_utils.html

Searches the system for installed Java versions and returns their directory paths.

```APIDOC
## find_system_java_versions(additional_directories)

### Description
Attempts to find all Java versions installed on the system. Note that macOS is not currently supported.

### Parameters
- **additional_directories** (list[str | PathLike] | None) - Optional - A list of additional directories to search for Java installations.

### Returns
- **list[str]** - A list of directory paths where Java installations were found.
```

--------------------------------

### find_system_java_versions_information(additional_directories)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/java_utils.html

Searches the system for Java versions and returns detailed information for each found installation.

```APIDOC
## find_system_java_versions_information(additional_directories)

### Description
Similar to find_system_java_versions, but returns detailed JavaInformation objects for each installation found. Note that this function executes the Java executable, which may pose a security risk. macOS is not currently supported.

### Parameters
- **additional_directories** (list[str | PathLike] | None) - Optional - A list of additional directories to search for Java installations.

### Returns
- **list[JavaInformation]** - A list of dictionaries containing detailed information about each discovered Java installation.
```

--------------------------------

### Get Latest Version

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/tutorial/getting_started.html

Retrieve the latest release and snapshot version identifiers.

```python
latest_release = minecraft_launcher_lib.utils.get_latest_version()["release"]
latest_snapshot = minecraft_launcher_lib.utils.get_latest_version()["snapshot"]
```

--------------------------------

### Initializing a PyQt Application

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/PyQtInstallation.rst.txt

Standard entry point for a PyQt application, creating the application instance and displaying the main window.

```python
def main():
    app = QApplication(sys.argv)

    w = Window()
    w.show()

    sys.exit(app.exec())


if __name__ == "__main__":
    main()
```

--------------------------------

### get_java_information(path)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/java_utils.html

Retrieves detailed information about a specific Java installation by executing the Java executable.

```APIDOC
## get_java_information(path)

### Description
Returns information about the given Java installation. Note that this function executes the Java executable to determine details, which may pose a security risk.

### Parameters
- **path** (str | PathLike) - Required - The directory path to the Java installation (e.g., the parent directory of the bin folder).

### Returns
- **JavaInformation** (dict) - A dictionary containing information about the Java installation.

### Raises
- **ValueError** - Raised if the provided path is invalid.
```

--------------------------------

### Create a Minecraft Launcher with Tkinter

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/examples/TkinterLauncher.rst.txt

This script initializes a Tkinter window to collect user credentials and select a Minecraft version, then uses minecraft-launcher-lib to install and launch the game.

```python
#!/usr/bin/env python3
# This example shows how to write a basic launcher with Tkinter.
from tkinter import Tk, Label, Entry, Button, mainloop
from tkinter.ttk import Combobox
import minecraft_launcher_lib
import subprocess
import sys


def main():
    def launch():
        window.withdraw()

        minecraft_launcher_lib.install.install_minecraft_version(version_select.get(), minecraft_directory)

        login_data = minecraft_launcher_lib.account.login_user(username_input.get(), password_input.get())

        options = {
            "username": login_data["selectedProfile"]["name"],
            "uuid": login_data["selectedProfile"]["id"],
            "token": login_data["accessToken"]
        }
        minecraft_command = minecraft_launcher_lib.command.get_minecraft_command(version_select.get(), minecraft_directory, options)

        subprocess.run(minecraft_command)

        sys.exit(0)

    window = Tk()
    window.title("Minecraft Launcher")

    Label(window, text="Username:").grid(row=0, column=0)
    username_input = Entry(window)
    username_input.grid(row=0, column=1)
    Label(window, text="Password:").grid(row=1, column=0)
    password_input = Entry(window)
    password_input.grid(row=1, column=1)

    minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
    versions = minecraft_launcher_lib.utils.get_available_versions(minecraft_directory)
    version_list = []

    for i in versions:
        version_list.append(i["id"])

    Label(window, text="Version:").grid(row=2, column=0)
    version_select = Combobox(window, values=version_list)
    version_select.grid(row=2, column=1)
    version_select.current(0)

    Button(window, text="Launch", command=launch).grid(row=4, column=1)

    mainloop()


if __name__ == "__main__":
    main()
```

--------------------------------

### Configure JVM Arguments

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/tutorial/more_launch_options.rst.txt

JVM arguments must be provided as a list of strings, where each argument starts with a hyphen.

```python
# Right
options["jvmArguments"] = ["-Xmx2G", "-Xms2G"]

# Wrong
options["jvmArguments"] = ["-Xmx2G -Xms2G"]

# Wrong
options["jvmArguments"] = "-Xmx2G -Xms2G"
```

--------------------------------

### PyQt6 Minecraft Launcher with Output Capture

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/examples/PyQtLauncherWithOutput.html

A full application script that integrates minecraft-launcher-lib with PyQt6. It handles authentication, version installation, and process management to display game logs.

```python
#!/usr/bin/env python3
# This example shows a simple launcher with PyQt that shows the output of Minecraft in a text filed
from PyQt6.QtWidgets import QApplication, QWidget, QPlainTextEdit, QLabel, QLineEdit, QPushButton, QComboBox, QMessageBox, QHBoxLayout, QVBoxLayout
from PyQt6.QtCore import QProcess
import minecraft_launcher_lib
import sys


class GameOutputWidget(QPlainTextEdit):
    def __init__(self, launch_button):
        super().__init__()
        self.setReadOnly(True)
        self.launch_button = launch_button
        # Disable line wrap
        self.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)

    def display_output(self):
        # This function displays the output of Minecraft in the text field
        cursor = self.textCursor()
        cursor.movePosition(cursor.MoveOperation.End)
        cursor.insertText(bytes(self.process.readAll()).decode())
        cursor.movePosition(cursor.MoveOperation.End)
        self.ensureCursorVisible()

    def execute_command(self, command):
        # QProcess.start takes as first argument the program and as second the list of arguments
        # So we need the filter the program from the command
        arguments = command[1:]
        # Deactivate the launch button
        self.launch_button.setEnabled(False)
        # Clear the text  field
        self.setPlainText("")
        self.process = QProcess(self)
        # Activate the launch button when Minecraft is closed
        self.process.finished.connect(lambda: self.launch_button.setEnabled(True))
        # Connect the function to display the output
        self.process.readyRead.connect(self.dataReady)
        # Start Minecraft
        self.process.start("java", arguments)


class MainWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.username_edit = QLineEdit()
        self.password_edit = QLineEdit()
        self.version_select = QComboBox()
        launch_button = QPushButton("Launch")
        self.output_widget = GameOutputWidget(launch_button)

        # Set the password field to display *
        self.password_edit.setEchoMode(QLineEdit.EchoMode.Password)

        launch_button.clicked.connect(self.launch_minecraft)

        # Add all versions to the Version ComboBox
        self.minecraft_directory = minecraft_launcher_lib.utils.get_minecraft_directory()
        for i in minecraft_launcher_lib.utils.get_available_versions(self.minecraft_directory):
            # Only add release versions
            if i["type"] == "release":
                self.version_select.addItem(i["id"])

        # Create the layouts
        bottom_layout = QHBoxLayout()
        bottom_layout.addWidget(QLabel("Username:"))
        bottom_layout.addWidget(self.username_edit)
        bottom_layout.addWidget(QLabel("Password:"))
        bottom_layout.addWidget(self.password_edit)
        bottom_layout.addWidget(QLabel("Version:"))
        bottom_layout.addWidget(self.version_select)
        bottom_layout.addWidget(launch_button)

        main_layout = QVBoxLayout()
        main_layout.addWidget(self.output_widget)
        main_layout.addLayout(bottom_layout)

        self.setLayout(main_layout)
        self.setGeometry(0, 0, 800, 600)
        self.setWindowTitle("PyQt Launcher with Output")

    def launch_minecraft(self):
        # Get the selected version
        version = self.version_select.currentText()

        # Make sure the version is installed
        minecraft_launcher_lib.install.install_minecraft_version(version, self.minecraft_directory)

        # Login
        login_data = minecraft_launcher_lib.account.login_user(self.username_edit.text(), self.password_edit.text())

        # Check if the login is correct
        if "errorMessage" in login_data:
            message_box = QMessageBox()
            message_box.setWindowTitle("Invalid credentials")
            message_box.setText("Invalid username or password")
            message_box.setStandardButtons(QMessageBox.StandardButtons.Ok)
            message_box.exec()
            return

        options = {
            "username": login_data["selectedProfile"]["name"],
            "uuid": login_data["selectedProfile"]["id"],
            "token": login_data["accessToken"]
        }

        # Get the command
        command = minecraft_launcher_lib.command.get_minecraft_command(version, self.minecraft_directory, options)

        # Call the function from the
        self.output_widget.execute_command(command)


def main():
    app = QApplication(sys.argv)
    w = MainWindow()
    w.show()
    sys.exit(app.exec())


if __name__ == "__main__":
    main()
```

--------------------------------

### Get all Fabric loader versions

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/fabric.html

Iterates through and prints all available Fabric loader versions.

```python
for version in minecraft_launcher_lib.fabric.get_all_loader_versions():
    print(version["version"])
```

--------------------------------

### is_minecraft_installed(minecraft_directory: str | PathLike) -> bool

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/utils.html

Verifies if a Minecraft installation exists within the specified directory path.

```APIDOC
## is_minecraft_installed(minecraft_directory: str | PathLike) -> bool

### Description
Checks if there is already an existing Minecraft installation in the given directory.

### Parameters
- **minecraft_directory** (str | PathLike) - Required - The path to your Minecraft directory.

### Returns
- **bool** - True if an installation is found, False otherwise.
```

--------------------------------

### forge_to_installed_version(forge_version)

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/forge.html

Maps a Forge version identifier to the internal version name used for installation.

```APIDOC
## forge_to_installed_version(forge_version)

### Description
Returns the Version under which Forge will be installed from the given Forge version.

### Parameters
- **forge_version** (str) - Required - A Forge Version identifier.

### Returns
- **str** - The installed version name.

### Raises
- **ValueError** - If the version is invalid.
```

--------------------------------

### Verify Local Library Installation

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/develop/testing_changes.rst.txt

Confirm that the Python interpreter is importing the local version of the library by checking its file path.

```python
>>> import minecraft_launcher_lib
>>> print(minecraft_launcher_lib.__file___)
```

--------------------------------

### Example Login Response Structure

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/_sources/tutorial/microsoft_login.rst.txt

The JSON object returned after a successful completion of the Microsoft login process.

```json
{
    "id" : "The uuid",
    "name" : "The username",
    "access_token": "The access token",
    "refresh_token": "The refresh token",
    "skins" : [{
        "id" : "6a6e65e5-76dd-4c3c-a625-162924514568",
        "state" : "ACTIVE",
        "url" : "http://textures.minecraft.net/texture/1a4af718455d4aab528e7a61f86fa25e6a369d1768dcb13f7df319a713eb810b",
        "variant" : "CLASSIC",
        "alias" : "STEVE"
    } ],
    "capes" : []
}
```

--------------------------------

### Get installed version for a mod loader

Source: https://minecraft-launcher-lib.readthedocs.io/en/stable/modules/mod_loader.html

Retrieves the version string under which a mod loader will be installed, suitable for use with command generation functions.

```python
vanilla_version = "1.21"
loader_version = "0.16.14"
mod_loader = minecraft_launcher_lib.mod_loader.get_mod_loader("fabric")
installed_version = mod_loader.get_installed_version(vanilla_version, loader_version)
print(installed_version)
```
Tokens:
Raw