NOISSUE add archived projects

Signed-off-by: Mehmet Samet Duman <yongdohyun@projecttick.org>

20 files changed, 2608 insertions, 0 deletions

diff --git a/archived/projt-launcher/launcher/java/core/RuntimeInstall.cpp b/archived/projt-launcher/launcher/java/core/RuntimeInstall.cpp
new file mode 100644
index 0000000000..4eff57d0fe
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimeInstall.cpp
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/core/RuntimeInstall.hpp"
+
+#include "BaseVersion.h"
+#include "StringUtils.h"
+
+#include <typeinfo>
+
+namespace projt::java
+{
+	bool RuntimeInstall::operator<(const RuntimeInstall& rhs) const
+	{
+		if (version < rhs.version)
+		{
+			return true;
+		}
+		if (version > rhs.version)
+		{
+			return false;
+		}
+		if (is_64bit != rhs.is_64bit)
+		{
+			return rhs.is_64bit;
+		}
+		auto archCompare = StringUtils::naturalCompare(arch, rhs.arch, Qt::CaseInsensitive);
+		if (archCompare != 0)
+		{
+			return archCompare < 0;
+		}
+		return StringUtils::naturalCompare(path, rhs.path, Qt::CaseInsensitive) < 0;
+	}
+
+	bool RuntimeInstall::operator==(const RuntimeInstall& rhs) const
+	{
+		return version == rhs.version && arch == rhs.arch && path == rhs.path && is_64bit == rhs.is_64bit;
+	}
+
+	bool RuntimeInstall::operator>(const RuntimeInstall& rhs) const
+	{
+		return (!operator<(rhs)) && (!operator==(rhs));
+	}
+
+	bool RuntimeInstall::operator<(BaseVersion& a) const
+	{
+		try
+		{
+			return operator<(dynamic_cast<RuntimeInstall&>(a));
+		}
+		catch (const std::bad_cast&)
+		{
+			return BaseVersion::operator<(a);
+		}
+	}
+
+	bool RuntimeInstall::operator>(BaseVersion& a) const
+	{
+		try
+		{
+			return operator>(dynamic_cast<RuntimeInstall&>(a));
+		}
+		catch (const std::bad_cast&)
+		{
+			return BaseVersion::operator>(a);
+		}
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/core/RuntimeInstall.hpp b/archived/projt-launcher/launcher/java/core/RuntimeInstall.hpp
new file mode 100644
index 0000000000..5039df2ecb
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimeInstall.hpp
@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "BaseVersion.h"
+#include "java/core/RuntimeVersion.hpp"
+
+#include <memory>
+#include <utility>
+
+namespace projt::java
+{
+	struct RuntimeInstall : public BaseVersion
+	{
+		RuntimeInstall() = default;
+		RuntimeInstall(RuntimeVersion version, QString arch, QString path)
+			: version(std::move(version)),
+			  arch(std::move(arch)),
+			  path(std::move(path))
+		{}
+
+		QString descriptor() const override
+		{
+			return version.toString();
+		}
+		QString name() const override
+		{
+			return version.toString();
+		}
+		QString typeString() const override
+		{
+			return arch;
+		}
+
+		bool operator<(BaseVersion& a) const override;
+		bool operator>(BaseVersion& a) const override;
+		bool operator<(const RuntimeInstall& rhs) const;
+		bool operator==(const RuntimeInstall& rhs) const;
+		bool operator>(const RuntimeInstall& rhs) const;
+
+		RuntimeVersion version;
+		QString arch;
+		QString path;
+		QString vendor;
+		bool recommended = false;
+		bool is_64bit	 = false;
+		bool managed	 = false;
+	};
+
+	using RuntimeInstallPtr = std::shared_ptr<RuntimeInstall>;
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/core/RuntimePackage.cpp b/archived/projt-launcher/launcher/java/core/RuntimePackage.cpp
new file mode 100644
index 0000000000..727201d1bd
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimePackage.cpp
@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/core/RuntimePackage.hpp"
+
+#include "Json.h"
+#include "StringUtils.h"
+#include "minecraft/ParseUtils.h"
+
+#include <typeinfo>
+
+namespace projt::java
+{
+	PackageKind parsePackageKind(const QString& raw)
+	{
+		if (raw == "manifest")
+		{
+			return PackageKind::Manifest;
+		}
+		if (raw == "archive")
+		{
+			return PackageKind::Archive;
+		}
+		return PackageKind::Unknown;
+	}
+
+	QString packageKindToString(PackageKind kind)
+	{
+		switch (kind)
+		{
+			case PackageKind::Manifest: return "manifest";
+			case PackageKind::Archive: return "archive";
+			case PackageKind::Unknown: break;
+		}
+		return "unknown";
+	}
+
+	RuntimePackagePtr parseRuntimePackage(const QJsonObject& in)
+	{
+		auto meta = std::make_shared<RuntimePackage>();
+
+		meta->displayName  = Json::ensureString(in, "name", "");
+		meta->vendor	   = Json::ensureString(in, "vendor", "");
+		meta->url		   = Json::ensureString(in, "url", "");
+		meta->releaseTime  = timeFromS3Time(Json::ensureString(in, "releaseTime", ""));
+		meta->downloadKind = parsePackageKind(Json::ensureString(in, "downloadType", ""));
+		meta->packageType  = Json::ensureString(in, "packageType", "");
+		meta->runtimeOS	   = Json::ensureString(in, "runtimeOS", "unknown");
+
+		if (in.contains("checksum"))
+		{
+			auto obj		   = Json::requireObject(in, "checksum");
+			meta->checksumHash = Json::ensureString(obj, "hash", "");
+			meta->checksumType = Json::ensureString(obj, "type", "");
+		}
+
+		if (in.contains("version"))
+		{
+			auto obj	  = Json::requireObject(in, "version");
+			auto name	  = Json::ensureString(obj, "name", "");
+			auto major	  = Json::ensureInteger(obj, "major", 0);
+			auto minor	  = Json::ensureInteger(obj, "minor", 0);
+			auto security = Json::ensureInteger(obj, "security", 0);
+			auto build	  = Json::ensureInteger(obj, "build", 0);
+			meta->version = RuntimeVersion(major, minor, security, build, name);
+		}
+		return meta;
+	}
+
+	bool RuntimePackage::operator<(const RuntimePackage& rhs) const
+	{
+		if (version < rhs.version)
+		{
+			return true;
+		}
+		if (version > rhs.version)
+		{
+			return false;
+		}
+		if (releaseTime < rhs.releaseTime)
+		{
+			return true;
+		}
+		if (releaseTime > rhs.releaseTime)
+		{
+			return false;
+		}
+		return StringUtils::naturalCompare(displayName, rhs.displayName, Qt::CaseInsensitive) < 0;
+	}
+
+	bool RuntimePackage::operator==(const RuntimePackage& rhs) const
+	{
+		return version == rhs.version && displayName == rhs.displayName;
+	}
+
+	bool RuntimePackage::operator>(const RuntimePackage& rhs) const
+	{
+		return (!operator<(rhs)) && (!operator==(rhs));
+	}
+
+	bool RuntimePackage::operator<(BaseVersion& a) const
+	{
+		try
+		{
+			return operator<(dynamic_cast<RuntimePackage&>(a));
+		}
+		catch (const std::bad_cast&)
+		{
+			return BaseVersion::operator<(a);
+		}
+	}
+
+	bool RuntimePackage::operator>(BaseVersion& a) const
+	{
+		try
+		{
+			return operator>(dynamic_cast<RuntimePackage&>(a));
+		}
+		catch (const std::bad_cast&)
+		{
+			return BaseVersion::operator>(a);
+		}
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/core/RuntimePackage.hpp b/archived/projt-launcher/launcher/java/core/RuntimePackage.hpp
new file mode 100644
index 0000000000..88ebaadf2c
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimePackage.hpp
@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QDateTime>
+#include <QJsonObject>
+#include <QString>
+
+#include <memory>
+
+#include "BaseVersion.h"
+#include "java/core/RuntimeVersion.hpp"
+
+namespace projt::java
+{
+	enum class PackageKind
+	{
+		Manifest,
+		Archive,
+		Unknown
+	};
+
+	class RuntimePackage : public BaseVersion
+	{
+	  public:
+		QString descriptor() const override
+		{
+			return version.toString();
+		}
+
+		QString name() const override
+		{
+			return displayName;
+		}
+
+		QString typeString() const override
+		{
+			return vendor;
+		}
+
+		bool operator<(BaseVersion& a) const override;
+		bool operator>(BaseVersion& a) const override;
+		bool operator<(const RuntimePackage& rhs) const;
+		bool operator==(const RuntimePackage& rhs) const;
+		bool operator>(const RuntimePackage& rhs) const;
+
+		QString displayName;
+		QString vendor;
+		QString url;
+		QDateTime releaseTime;
+		QString checksumType;
+		QString checksumHash;
+		PackageKind downloadKind = PackageKind::Unknown;
+		QString packageType;
+		RuntimeVersion version;
+		QString runtimeOS;
+	};
+
+	using RuntimePackagePtr = std::shared_ptr<RuntimePackage>;
+
+	PackageKind parsePackageKind(const QString& raw);
+	QString packageKindToString(PackageKind kind);
+	RuntimePackagePtr parseRuntimePackage(const QJsonObject& obj);
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/core/RuntimeVersion.cpp b/archived/projt-launcher/launcher/java/core/RuntimeVersion.cpp
new file mode 100644
index 0000000000..cd2e07a9d9
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimeVersion.cpp
@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "java/core/RuntimeVersion.hpp"
+
+#include "StringUtils.h"
+
+#include <QStringList>
+
+namespace projt::java
+{
+	RuntimeVersion::RuntimeVersion(const QString& raw)
+	{
+		parse(raw);
+	}
+
+	RuntimeVersion::RuntimeVersion(int major, int minor, int security, int build, QString name)
+		: m_major(major),
+		  m_minor(minor),
+		  m_security(security),
+		  m_name(name),
+		  m_valid(true)
+	{
+		QStringList parts;
+		if (build != 0)
+		{
+			m_prerelease = QString::number(build);
+			parts.push_front(m_prerelease);
+		}
+		if (m_security != 0)
+		{
+			parts.push_front(QString::number(m_security));
+		}
+		else if (!parts.isEmpty())
+		{
+			parts.push_front("0");
+		}
+
+		if (m_minor != 0)
+		{
+			parts.push_front(QString::number(m_minor));
+		}
+		else if (!parts.isEmpty())
+		{
+			parts.push_front("0");
+		}
+		parts.push_front(QString::number(m_major));
+		m_raw = parts.join(".");
+	}
+
+	RuntimeVersion& RuntimeVersion::operator=(const QString& raw)
+	{
+		parse(raw);
+		return *this;
+	}
+
+	void RuntimeVersion::parse(const QString& raw)
+	{
+		m_raw	   = raw.trimmed();
+		m_major	   = 0;
+		m_minor	   = 0;
+		m_security = 0;
+		m_prerelease.clear();
+		m_valid = false;
+
+		QString numeric = m_raw;
+		auto dashIndex	= numeric.indexOf('-');
+		if (dashIndex >= 0)
+		{
+			m_prerelease = numeric.mid(dashIndex + 1).trimmed();
+			numeric		 = numeric.left(dashIndex);
+		}
+
+		int updateNumber = 0;
+		auto updateIndex = numeric.indexOf('_');
+		if (updateIndex >= 0)
+		{
+			bool ok		 = false;
+			updateNumber = numeric.mid(updateIndex + 1).toInt(&ok);
+			if (!ok)
+			{
+				updateNumber = 0;
+			}
+			numeric = numeric.left(updateIndex);
+		}
+
+		numeric.replace('_', '.');
+		QStringList parts = numeric.split('.', Qt::SkipEmptyParts);
+		if (!parts.isEmpty() && parts[0] == "1" && parts.size() > 1)
+		{
+			parts.removeFirst();
+		}
+		if (parts.isEmpty())
+		{
+			return;
+		}
+
+		auto parsePart = [](const QString& value, int& out)
+		{
+			bool ok	   = false;
+			int parsed = value.toInt(&ok);
+			if (!ok)
+			{
+				return false;
+			}
+			out = parsed;
+			return true;
+		};
+
+		if (!parsePart(parts[0], m_major))
+		{
+			return;
+		}
+		m_valid = true;
+		if (parts.size() > 1)
+		{
+			parsePart(parts[1], m_minor);
+		}
+		if (parts.size() > 2)
+		{
+			parsePart(parts[2], m_security);
+		}
+		if (updateNumber != 0)
+		{
+			m_security = updateNumber;
+		}
+	}
+
+	QString RuntimeVersion::toString() const
+	{
+		return m_raw;
+	}
+
+	bool RuntimeVersion::needsPermGen() const
+	{
+		return !m_valid || m_major <= 7;
+	}
+
+	bool RuntimeVersion::defaultsToUtf8() const
+	{
+		return m_valid && m_major >= 18;
+	}
+
+	bool RuntimeVersion::supportsModules() const
+	{
+		return m_valid && m_major >= 9;
+	}
+
+	bool RuntimeVersion::operator<(const RuntimeVersion& rhs) const
+	{
+		if (m_valid && rhs.m_valid)
+		{
+			if (m_major != rhs.m_major)
+			{
+				return m_major < rhs.m_major;
+			}
+			if (m_minor != rhs.m_minor)
+			{
+				return m_minor < rhs.m_minor;
+			}
+			if (m_security != rhs.m_security)
+			{
+				return m_security < rhs.m_security;
+			}
+
+			bool thisPre = !m_prerelease.isEmpty();
+			bool rhsPre	 = !rhs.m_prerelease.isEmpty();
+			if (thisPre != rhsPre)
+			{
+				return thisPre;
+			}
+			if (thisPre && rhsPre)
+			{
+				return StringUtils::naturalCompare(m_prerelease, rhs.m_prerelease, Qt::CaseSensitive) < 0;
+			}
+			return false;
+		}
+		return StringUtils::naturalCompare(m_raw, rhs.m_raw, Qt::CaseSensitive) < 0;
+	}
+
+	bool RuntimeVersion::operator==(const RuntimeVersion& rhs) const
+	{
+		if (m_valid && rhs.m_valid)
+		{
+			return m_major == rhs.m_major && m_minor == rhs.m_minor && m_security == rhs.m_security
+				&& m_prerelease == rhs.m_prerelease;
+		}
+		return m_raw == rhs.m_raw;
+	}
+
+	bool RuntimeVersion::operator>(const RuntimeVersion& rhs) const
+	{
+		return (!operator<(rhs)) && (!operator==(rhs));
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/core/RuntimeVersion.hpp b/archived/projt-launcher/launcher/java/core/RuntimeVersion.hpp
new file mode 100644
index 0000000000..7199add778
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/core/RuntimeVersion.hpp
@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QString>
+
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+
+namespace projt::java
+{
+	class RuntimeVersion
+	{
+		friend class RuntimeVersionTest;
+
+	  public:
+		RuntimeVersion() = default;
+		explicit RuntimeVersion(const QString& raw);
+		RuntimeVersion(int major, int minor, int security, int build = 0, QString name = "");
+
+		RuntimeVersion& operator=(const QString& raw);
+
+		bool operator<(const RuntimeVersion& rhs) const;
+		bool operator==(const RuntimeVersion& rhs) const;
+		bool operator>(const RuntimeVersion& rhs) const;
+
+		bool needsPermGen() const;
+		bool defaultsToUtf8() const;
+		bool supportsModules() const;
+
+		QString toString() const;
+
+		int major() const
+		{
+			return m_major;
+		}
+		int minor() const
+		{
+			return m_minor;
+		}
+		int security() const
+		{
+			return m_security;
+		}
+		QString prerelease() const
+		{
+			return m_prerelease;
+		}
+		QString name() const
+		{
+			return m_name;
+		}
+
+	  private:
+		void parse(const QString& raw);
+
+		QString m_raw;
+		int m_major	   = 0;
+		int m_minor	   = 0;
+		int m_security = 0;
+		QString m_name;
+		bool m_valid = false;
+		QString m_prerelease;
+	};
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.cpp b/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.cpp
new file mode 100644
index 0000000000..9ab74afe62
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.cpp
@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "java/download/RuntimeArchiveTask.hpp"
+
+#include <QDir>
+#include <QFile>
+#include <memory>
+#include <quazip.h>
+
+#include "Application.h"
+#include "MMCZip.h"
+#include "Untar.h"
+#include "net/ChecksumValidator.h"
+#include "net/NetJob.h"
+
+namespace projt::java
+{
+	RuntimeArchiveTask::RuntimeArchiveTask(QUrl url, QString finalPath, QString checksumType, QString checksumHash)
+		: m_url(url),
+		  m_final_path(std::move(finalPath)),
+		  m_checksum_type(std::move(checksumType)),
+		  m_checksum_hash(std::move(checksumHash))
+	{}
+
+	void RuntimeArchiveTask::executeTask()
+	{
+		setStatus(tr("Downloading Java"));
+
+		MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("java", m_url.fileName());
+
+		auto download = makeShared<NetJob>(QString("JRE::DownloadJava"), APPLICATION->network());
+		auto action	  = Net::Download::makeCached(m_url, entry);
+		if (!m_checksum_hash.isEmpty() && !m_checksum_type.isEmpty())
+		{
+			auto hashType = QCryptographicHash::Algorithm::Sha1;
+			if (m_checksum_type == "sha256")
+			{
+				hashType = QCryptographicHash::Algorithm::Sha256;
+			}
+			action->addValidator(new Net::ChecksumValidator(hashType, QByteArray::fromHex(m_checksum_hash.toUtf8())));
+		}
+		download->addNetAction(action);
+		auto fullPath = entry->getFullPath();
+
+		connect(download.get(), &Task::failed, this, &RuntimeArchiveTask::emitFailed);
+		connect(download.get(), &Task::progress, this, &RuntimeArchiveTask::setProgress);
+		connect(download.get(), &Task::stepProgress, this, &RuntimeArchiveTask::propagateStepProgress);
+		connect(download.get(), &Task::status, this, &RuntimeArchiveTask::setStatus);
+		connect(download.get(), &Task::details, this, &RuntimeArchiveTask::setDetails);
+		connect(download.get(), &Task::aborted, this, &RuntimeArchiveTask::emitAborted);
+		connect(download.get(), &Task::succeeded, this, [this, fullPath] { extractRuntime(fullPath); });
+		m_task = download;
+		m_task->start();
+	}
+
+	void RuntimeArchiveTask::extractRuntime(QString input)
+	{
+		setStatus(tr("Extracting Java"));
+		if (input.endsWith("tar"))
+		{
+			setStatus(tr("Extracting Java (Progress is not reported for tar archives)"));
+			QFile in(input);
+			if (!in.open(QFile::ReadOnly))
+			{
+				emitFailed(tr("Unable to open supplied tar file."));
+				return;
+			}
+			if (!Tar::extract(&in, QDir(m_final_path).absolutePath()))
+			{
+				emitFailed(tr("Unable to extract supplied tar file."));
+				return;
+			}
+			emitSucceeded();
+			return;
+		}
+		if (input.endsWith("tar.gz") || input.endsWith("taz") || input.endsWith("tgz"))
+		{
+			setStatus(tr("Extracting Java (Progress is not reported for tar archives)"));
+			if (!GZTar::extract(input, QDir(m_final_path).absolutePath()))
+			{
+				emitFailed(tr("Unable to extract supplied tar file."));
+				return;
+			}
+			emitSucceeded();
+			return;
+		}
+		if (input.endsWith("zip"))
+		{
+			auto zip = std::make_shared<QuaZip>(input);
+			if (!zip->open(QuaZip::mdUnzip))
+			{
+				emitFailed(tr("Unable to open supplied zip file."));
+				return;
+			}
+			auto files = zip->getFileNameList();
+			if (files.isEmpty())
+			{
+				emitFailed(tr("No files were found in the supplied zip file."));
+				return;
+			}
+			m_task = makeShared<MMCZip::ExtractZipTask>(zip, m_final_path, files[0]);
+
+			auto progressStep = std::make_shared<TaskStepProgress>();
+			connect(m_task.get(),
+					&Task::finished,
+					this,
+					[this, progressStep]
+					{
+						progressStep->state = TaskStepState::Succeeded;
+						stepProgress(*progressStep);
+					});
+
+			connect(m_task.get(), &Task::succeeded, this, &RuntimeArchiveTask::emitSucceeded);
+			connect(m_task.get(), &Task::aborted, this, &RuntimeArchiveTask::emitAborted);
+			connect(m_task.get(),
+					&Task::failed,
+					this,
+					[this, progressStep](QString reason)
+					{
+						progressStep->state = TaskStepState::Failed;
+						stepProgress(*progressStep);
+						emitFailed(reason);
+					});
+			connect(m_task.get(), &Task::stepProgress, this, &RuntimeArchiveTask::propagateStepProgress);
+
+			connect(m_task.get(),
+					&Task::progress,
+					this,
+					[this, progressStep](qint64 current, qint64 total)
+					{
+						progressStep->update(current, total);
+						stepProgress(*progressStep);
+					});
+			connect(m_task.get(),
+					&Task::status,
+					this,
+					[this, progressStep](QString status)
+					{
+						progressStep->status = status;
+						stepProgress(*progressStep);
+					});
+			m_task->start();
+			return;
+		}
+
+		emitFailed(tr("Could not determine archive type!"));
+	}
+
+	bool RuntimeArchiveTask::abort()
+	{
+		auto aborted = canAbort();
+		if (m_task)
+			aborted = m_task->abort();
+		return aborted;
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.hpp b/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.hpp
new file mode 100644
index 0000000000..6aa524ceb2
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeArchiveTask.hpp
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QUrl>
+
+#include "tasks/Task.h"
+
+namespace projt::java
+{
+	class RuntimeArchiveTask : public Task
+	{
+		Q_OBJECT
+	  public:
+		RuntimeArchiveTask(QUrl url, QString finalPath, QString checksumType = "", QString checksumHash = "");
+		~RuntimeArchiveTask() override = default;
+
+		bool canAbort() const override
+		{
+			return true;
+		}
+
+		bool abort() override;
+
+	  protected:
+		void executeTask() override;
+
+	  private:
+		void extractRuntime(QString input);
+
+		QUrl m_url;
+		QString m_final_path;
+		QString m_checksum_type;
+		QString m_checksum_hash;
+		Task::Ptr m_task;
+	};
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.cpp b/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.cpp
new file mode 100644
index 0000000000..fd5b381044
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.cpp
@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "java/download/RuntimeLinkTask.hpp"
+
+#include <QDir>
+#include <QFileInfo>
+
+#include "FileSystem.h"
+
+namespace
+{
+	QString findBinPath(const QString& root, const QString& pattern)
+	{
+		auto path = FS::PathCombine(root, pattern);
+		if (QFileInfo::exists(path))
+		{
+			return path;
+		}
+
+		auto entries = QDir(root).entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (auto& entry : entries)
+		{
+			path = FS::PathCombine(entry.absoluteFilePath(), pattern);
+			if (QFileInfo::exists(path))
+			{
+				return path;
+			}
+		}
+
+		return {};
+	}
+} // namespace
+
+namespace projt::java
+{
+	RuntimeLinkTask::RuntimeLinkTask(QString finalPath) : m_path(std::move(finalPath))
+	{}
+
+	void RuntimeLinkTask::executeTask()
+	{
+		setStatus(tr("Checking for Java binary path"));
+		const auto binPath	  = FS::PathCombine("bin", "java");
+		const auto wantedPath = FS::PathCombine(m_path, binPath);
+		if (QFileInfo::exists(wantedPath))
+		{
+			emitSucceeded();
+			return;
+		}
+
+		setStatus(tr("Searching for Java binary path"));
+		const auto contentsPartialPath = FS::PathCombine("Contents", "Home", binPath);
+		const auto relativePathToBin   = findBinPath(m_path, contentsPartialPath);
+		if (relativePathToBin.isEmpty())
+		{
+			emitFailed(tr("Failed to find Java binary path"));
+			return;
+		}
+		const auto folderToLink = relativePathToBin.chopped(binPath.length());
+
+		setStatus(tr("Collecting folders to symlink"));
+		auto entries = QDir(folderToLink).entryInfoList(QDir::NoDotAndDotDot | QDir::AllEntries);
+		QList<FS::LinkPair> files;
+		setProgress(0, entries.length());
+		for (auto& entry : entries)
+		{
+			files.append({ entry.absoluteFilePath(), FS::PathCombine(m_path, entry.fileName()) });
+		}
+
+		setStatus(tr("Symlinking Java binary path"));
+		FS::create_link folderLink(files);
+		connect(&folderLink,
+				&FS::create_link::fileLinked,
+				[this](QString, QString) { setProgress(m_progress + 1, m_progressTotal); });
+		if (!folderLink())
+		{
+			emitFailed(folderLink.getOSError().message().c_str());
+		}
+		else
+		{
+			emitSucceeded();
+		}
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.hpp b/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.hpp
new file mode 100644
index 0000000000..d4daf98a04
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeLinkTask.hpp
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include "tasks/Task.h"
+
+namespace projt::java
+{
+	class RuntimeLinkTask : public Task
+	{
+		Q_OBJECT
+	  public:
+		explicit RuntimeLinkTask(QString finalPath);
+		~RuntimeLinkTask() override = default;
+
+	  protected:
+		void executeTask() override;
+
+	  private:
+		QString m_path;
+	};
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.cpp b/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.cpp
new file mode 100644
index 0000000000..3776078ecf
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.cpp
@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#include "java/download/RuntimeManifestTask.hpp"
+
+#include <QFile>
+#include <QJsonDocument>
+
+#include "Application.h"
+#include "FileSystem.h"
+#include "Json.h"
+#include "net/ChecksumValidator.h"
+#include "net/NetJob.h"
+
+namespace
+{
+	struct FileEntry
+	{
+		QString path;
+		QString url;
+		QByteArray hash;
+		bool isExec = false;
+	};
+} // namespace
+
+namespace projt::java
+{
+	RuntimeManifestTask::RuntimeManifestTask(QUrl url, QString finalPath, QString checksumType, QString checksumHash)
+		: m_url(url),
+		  m_final_path(std::move(finalPath)),
+		  m_checksum_type(std::move(checksumType)),
+		  m_checksum_hash(std::move(checksumHash))
+	{}
+
+	void RuntimeManifestTask::executeTask()
+	{
+		setStatus(tr("Downloading Java"));
+		auto download = makeShared<NetJob>(QString("JRE::DownloadJava"), APPLICATION->network());
+		auto files	  = std::make_shared<QByteArray>();
+
+		auto action = Net::Download::makeByteArray(m_url, files);
+		if (!m_checksum_hash.isEmpty() && !m_checksum_type.isEmpty())
+		{
+			auto hashType = QCryptographicHash::Algorithm::Sha1;
+			if (m_checksum_type == "sha256")
+			{
+				hashType = QCryptographicHash::Algorithm::Sha256;
+			}
+			action->addValidator(new Net::ChecksumValidator(hashType, QByteArray::fromHex(m_checksum_hash.toUtf8())));
+		}
+		download->addNetAction(action);
+
+		connect(download.get(), &Task::failed, this, &RuntimeManifestTask::emitFailed);
+		connect(download.get(), &Task::progress, this, &RuntimeManifestTask::setProgress);
+		connect(download.get(), &Task::stepProgress, this, &RuntimeManifestTask::propagateStepProgress);
+		connect(download.get(), &Task::status, this, &RuntimeManifestTask::setStatus);
+		connect(download.get(), &Task::details, this, &RuntimeManifestTask::setDetails);
+
+		connect(download.get(),
+				&Task::succeeded,
+				[files, this]
+				{
+					QJsonParseError parse_error{};
+					QJsonDocument doc = QJsonDocument::fromJson(*files, &parse_error);
+					if (parse_error.error != QJsonParseError::NoError)
+					{
+						qWarning() << "Error while parsing JSON response at " << parse_error.offset
+								   << ". Reason: " << parse_error.errorString();
+						qWarning() << *files;
+						emitFailed(parse_error.errorString());
+						return;
+					}
+					downloadRuntime(doc);
+				});
+		m_task = download;
+		m_task->start();
+	}
+
+	void RuntimeManifestTask::downloadRuntime(const QJsonDocument& doc)
+	{
+		FS::ensureFolderPathExists(m_final_path);
+		std::vector<FileEntry> toDownload;
+		auto list = Json::ensureObject(Json::ensureObject(doc.object()), "files");
+		for (const auto& pathKey : list.keys())
+		{
+			auto filePath			= FS::PathCombine(m_final_path, pathKey);
+			const QJsonObject& meta = Json::ensureObject(list, pathKey);
+			auto type				= Json::ensureString(meta, "type");
+			if (type == "directory")
+			{
+				FS::ensureFolderPathExists(filePath);
+			}
+			else if (type == "link")
+			{
+				auto target = Json::ensureString(meta, "target");
+				if (!target.isEmpty())
+				{
+					QFile::link(target, filePath);
+				}
+			}
+			else if (type == "file")
+			{
+				auto downloads = Json::ensureObject(meta, "downloads");
+				auto isExec	   = Json::ensureBoolean(meta, "executable", false);
+				QString url;
+				QByteArray hash;
+
+				if (downloads.contains("raw"))
+				{
+					auto raw = Json::ensureObject(downloads, "raw");
+					url		 = Json::ensureString(raw, "url");
+					hash	 = QByteArray::fromHex(Json::ensureString(raw, "sha1").toLatin1());
+				}
+				else
+				{
+					qWarning() << "No raw download available for file:" << pathKey;
+					qWarning() << "Skipping file without raw download - decompression not yet supported";
+					continue;
+				}
+
+				if (!url.isEmpty() && QUrl(url).isValid())
+				{
+					toDownload.push_back({ filePath, url, hash, isExec });
+				}
+			}
+		}
+		auto elementDownload = makeShared<NetJob>("JRE::FileDownload", APPLICATION->network());
+		for (const auto& file : toDownload)
+		{
+			auto dl = Net::Download::makeFile(file.url, file.path);
+			if (!file.hash.isEmpty())
+			{
+				dl->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, file.hash));
+			}
+			if (file.isExec)
+			{
+				connect(dl.get(),
+						&Net::Download::succeeded,
+						[file]
+						{
+							QFile(file.path).setPermissions(QFile(file.path).permissions()
+															| QFileDevice::Permissions(0x1111));
+						});
+			}
+			elementDownload->addNetAction(dl);
+		}
+
+		connect(elementDownload.get(), &Task::failed, this, &RuntimeManifestTask::emitFailed);
+		connect(elementDownload.get(), &Task::progress, this, &RuntimeManifestTask::setProgress);
+		connect(elementDownload.get(), &Task::stepProgress, this, &RuntimeManifestTask::propagateStepProgress);
+		connect(elementDownload.get(), &Task::status, this, &RuntimeManifestTask::setStatus);
+		connect(elementDownload.get(), &Task::details, this, &RuntimeManifestTask::setDetails);
+
+		connect(elementDownload.get(), &Task::succeeded, this, &RuntimeManifestTask::emitSucceeded);
+		m_task = elementDownload;
+		m_task->start();
+	}
+
+	bool RuntimeManifestTask::abort()
+	{
+		auto aborted = canAbort();
+		if (m_task)
+			aborted = m_task->abort();
+		emitAborted();
+		return aborted;
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.hpp b/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.hpp
new file mode 100644
index 0000000000..6eb8427dbe
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/download/RuntimeManifestTask.hpp
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QUrl>
+
+#include "tasks/Task.h"
+
+namespace projt::java
+{
+	class RuntimeManifestTask : public Task
+	{
+		Q_OBJECT
+	  public:
+		RuntimeManifestTask(QUrl url, QString finalPath, QString checksumType = "", QString checksumHash = "");
+		~RuntimeManifestTask() override = default;
+
+		bool canAbort() const override
+		{
+			return true;
+		}
+
+		bool abort() override;
+
+	  protected:
+		void executeTask() override;
+
+	  private:
+		void downloadRuntime(const QJsonDocument& doc);
+
+		QUrl m_url;
+		QString m_final_path;
+		QString m_checksum_type;
+		QString m_checksum_hash;
+		Task::Ptr m_task;
+	};
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeCatalog.cpp b/archived/projt-launcher/launcher/java/services/RuntimeCatalog.cpp
new file mode 100644
index 0000000000..f7fbc00602
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeCatalog.cpp
@@ -0,0 +1,205 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/services/RuntimeCatalog.hpp"
+
+#include <QtNetwork>
+#include <QtXml>
+
+#include <QDebug>
+#include <algorithm>
+
+#include "Application.h"
+#include "java/services/RuntimeScanner.hpp"
+#include "tasks/ConcurrentTask.h"
+
+namespace projt::java
+{
+	RuntimeCatalog::RuntimeCatalog(QObject* parent, Scope scope) : BaseVersionList(parent), m_scope(scope)
+	{}
+
+	Task::Ptr RuntimeCatalog::getLoadTask()
+	{
+		load();
+		return currentTask();
+	}
+
+	Task::Ptr RuntimeCatalog::currentTask() const
+	{
+		if (m_state == State::Loading)
+		{
+			return m_task;
+		}
+		return nullptr;
+	}
+
+	void RuntimeCatalog::load()
+	{
+		if (m_state != State::Loading)
+		{
+			m_state = State::Loading;
+			m_task.reset(new RuntimeCatalogTask(this, m_scope));
+			m_task->start();
+		}
+	}
+
+	const BaseVersion::Ptr RuntimeCatalog::at(int i) const
+	{
+		return m_entries.at(i);
+	}
+
+	bool RuntimeCatalog::isLoaded()
+	{
+		return m_state == State::Ready;
+	}
+
+	int RuntimeCatalog::count() const
+	{
+		return m_entries.count();
+	}
+
+	QVariant RuntimeCatalog::data(const QModelIndex& index, int role) const
+	{
+		if (!index.isValid())
+			return QVariant();
+
+		if (index.row() > count())
+			return QVariant();
+
+		auto runtime = std::dynamic_pointer_cast<RuntimeInstall>(m_entries[index.row()]);
+		switch (role)
+		{
+			case SortRole: return -index.row();
+			case VersionPointerRole: return QVariant::fromValue(m_entries[index.row()]);
+			case VersionIdRole: return runtime->descriptor();
+			case VersionRole: return runtime->version.toString();
+			case RecommendedRole: return false;
+			case PathRole: return runtime->path;
+			case CPUArchitectureRole: return runtime->arch;
+			default: return QVariant();
+		}
+	}
+
+	BaseVersionList::RoleList RuntimeCatalog::providesRoles() const
+	{
+		return { VersionPointerRole, VersionIdRole, VersionRole, RecommendedRole, PathRole, CPUArchitectureRole };
+	}
+
+	void RuntimeCatalog::updateListData(QList<BaseVersion::Ptr> versions)
+	{
+		beginResetModel();
+		m_entries = std::move(versions);
+		sortVersions();
+		endResetModel();
+		m_state = State::Ready;
+		m_task.reset();
+	}
+
+	static bool sortRuntimes(BaseVersion::Ptr left, BaseVersion::Ptr right)
+	{
+		auto rleft	= std::dynamic_pointer_cast<RuntimeInstall>(right);
+		auto rright = std::dynamic_pointer_cast<RuntimeInstall>(left);
+		return (*rleft) > (*rright);
+	}
+
+	void RuntimeCatalog::sortVersions()
+	{
+		std::sort(m_entries.begin(), m_entries.end(), sortRuntimes);
+	}
+
+	RuntimeCatalogTask::RuntimeCatalogTask(RuntimeCatalog* catalog, RuntimeCatalog::Scope scope)
+		: Task(),
+		  m_catalog(catalog),
+		  m_scope(scope)
+	{}
+
+	void RuntimeCatalogTask::executeTask()
+	{
+		setStatus(tr("Detecting Java installations..."));
+
+		RuntimeScanner scanner;
+		QStringList candidatePaths = scanner.collectPaths(m_scope == RuntimeCatalog::Scope::ManagedOnly);
+
+		ConcurrentTask::Ptr job(
+			new ConcurrentTask("Runtime detection", APPLICATION->settings()->get("NumberOfConcurrentTasks").toInt()));
+		m_job.reset(job);
+		connect(m_job.get(), &Task::finished, this, &RuntimeCatalogTask::probeFinished);
+		connect(m_job.get(), &Task::progress, this, &Task::setProgress);
+
+		qDebug() << "Probing the following runtime paths:";
+		int token = 0;
+		for (const auto& candidate : candidatePaths)
+		{
+			RuntimeProbeTask::ProbeSettings settings;
+			settings.binaryPath = candidate;
+			settings.token		= token;
+			auto probe			= new RuntimeProbeTask(settings);
+			connect(probe,
+					&RuntimeProbeTask::probeFinished,
+					this,
+					[this](const RuntimeProbeTask::ProbeReport& report) { m_results << report; });
+			job->addTask(Task::Ptr(probe));
+			token++;
+		}
+
+		m_job->start();
+	}
+
+	void RuntimeCatalogTask::probeFinished()
+	{
+		QList<RuntimeInstallPtr> candidates;
+		std::sort(m_results.begin(),
+				  m_results.end(),
+				  [](const RuntimeProbeTask::ProbeReport& a, const RuntimeProbeTask::ProbeReport& b)
+				  { return a.token < b.token; });
+
+		qDebug() << "Found the following valid Java installations:";
+		for (const auto& result : m_results)
+		{
+			if (result.status == RuntimeProbeTask::ProbeReport::Status::Valid)
+			{
+				RuntimeInstallPtr runtime(new RuntimeInstall());
+				runtime->version  = result.version;
+				runtime->arch	  = result.platformArch;
+				runtime->path	  = result.path;
+				runtime->vendor	  = result.vendor;
+				runtime->is_64bit = result.is_64bit;
+				runtime->managed  = (m_scope == RuntimeCatalog::Scope::ManagedOnly);
+				candidates.append(runtime);
+
+				qDebug() << " " << runtime->version.toString() << runtime->arch << runtime->path;
+			}
+		}
+
+		QList<BaseVersion::Ptr> entries;
+		for (const auto& runtime : candidates)
+		{
+			BaseVersion::Ptr base = std::dynamic_pointer_cast<BaseVersion>(runtime);
+			if (base)
+			{
+				entries.append(runtime);
+			}
+		}
+
+		m_catalog->updateListData(entries);
+		emitSucceeded();
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeCatalog.hpp b/archived/projt-launcher/launcher/java/services/RuntimeCatalog.hpp
new file mode 100644
index 0000000000..ddb2fc53a4
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeCatalog.hpp
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+
+#include "BaseVersionList.h"
+#include "QObjectPtr.h"
+#include "java/core/RuntimeInstall.hpp"
+#include "java/services/RuntimeProbeTask.hpp"
+#include "tasks/Task.h"
+
+namespace projt::java
+{
+	class RuntimeCatalogTask;
+
+	class RuntimeCatalog : public BaseVersionList
+	{
+		Q_OBJECT
+		enum class State
+		{
+			Idle,
+			Loading,
+			Ready
+		};
+
+	  public:
+		enum class Scope
+		{
+			All,
+			ManagedOnly
+		};
+
+		explicit RuntimeCatalog(QObject* parent = nullptr, Scope scope = Scope::All);
+
+		Task::Ptr getLoadTask() override;
+		bool isLoaded() override;
+		const BaseVersion::Ptr at(int i) const override;
+		int count() const override;
+		void sortVersions() override;
+
+		QVariant data(const QModelIndex& index, int role) const override;
+		RoleList providesRoles() const override;
+
+	  public slots:
+		void updateListData(QList<BaseVersion::Ptr> versions) override;
+
+	  private:
+		void load();
+		Task::Ptr currentTask() const;
+
+		State m_state = State::Idle;
+		shared_qobject_ptr<RuntimeCatalogTask> m_task;
+		QList<BaseVersion::Ptr> m_entries;
+		Scope m_scope;
+	};
+
+	class RuntimeCatalogTask : public Task
+	{
+		Q_OBJECT
+
+	  public:
+		explicit RuntimeCatalogTask(RuntimeCatalog* catalog, RuntimeCatalog::Scope scope);
+		~RuntimeCatalogTask() override = default;
+
+	  protected:
+		void executeTask() override;
+
+	  public slots:
+		void probeFinished();
+
+	  private:
+		Task::Ptr m_job;
+		RuntimeCatalog* m_catalog = nullptr;
+		QList<RuntimeProbeTask::ProbeReport> m_results;
+		RuntimeCatalog::Scope m_scope;
+	};
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.cpp b/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.cpp
new file mode 100644
index 0000000000..e6f027e462
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.cpp
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/services/RuntimeEnvironment.hpp"
+
+#include <QDebug>
+
+#define IBUS "@im=ibus"
+
+namespace projt::java
+{
+	QString stripEnvEntries(const QString& name, const QString& value, const QString& remove)
+	{
+		QChar delimiter = ':';
+#ifdef Q_OS_WIN32
+		delimiter = ';';
+#endif
+
+		QStringList targetItems = value.split(delimiter);
+		QStringList toRemove	= remove.split(delimiter);
+
+		for (const QString& item : toRemove)
+		{
+			if (!targetItems.removeOne(item))
+			{
+				qWarning() << "Entry" << item << "could not be stripped from variable" << name;
+			}
+		}
+		return targetItems.join(delimiter);
+	}
+
+	QProcessEnvironment buildCleanEnvironment()
+	{
+		QProcessEnvironment rawenv = QProcessEnvironment::systemEnvironment();
+		QProcessEnvironment env;
+
+		QStringList ignored = { "JAVA_ARGS", "CLASSPATH",	  "CONFIGPATH",	  "JAVA_HOME",
+								"JRE_HOME",	 "_JAVA_OPTIONS", "JAVA_OPTIONS", "JAVA_TOOL_OPTIONS" };
+
+		QStringList stripped = {
+#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
+			"LD_LIBRARY_PATH",
+			"LD_PRELOAD",
+#endif
+			"QT_PLUGIN_PATH",
+			"QT_FONTPATH"
+		};
+
+		for (const auto& key : rawenv.keys())
+		{
+			auto current = rawenv.value(key);
+			if (ignored.contains(key))
+			{
+				qDebug() << "Env: ignoring" << key << current;
+				continue;
+			}
+			if (key.startsWith("LAUNCHER_"))
+			{
+				qDebug() << "Env: ignoring" << key << current;
+				continue;
+			}
+			if (stripped.contains(key))
+			{
+				QString cleaned = stripEnvEntries(key, current, rawenv.value("LAUNCHER_" + key));
+				qDebug() << "Env: stripped" << key << current << "to" << cleaned;
+				current = cleaned;
+			}
+#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
+			if (key == "XMODIFIERS" && current.contains(IBUS))
+			{
+				QString saved = current;
+				current.replace(IBUS, "");
+				qDebug() << "Env: stripped" << IBUS << "from" << saved << ":" << current;
+			}
+#endif
+			env.insert(key, current);
+		}
+#ifdef Q_OS_LINUX
+		if (!env.contains("LD_LIBRARY_PATH"))
+		{
+			env.insert("LD_LIBRARY_PATH", "");
+		}
+#endif
+
+		return env;
+	}
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.hpp b/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.hpp
new file mode 100644
index 0000000000..7101fc51ad
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeEnvironment.hpp
@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QProcessEnvironment>
+#include <QString>
+
+namespace projt::java
+{
+	QString stripEnvEntries(const QString& name, const QString& value, const QString& remove);
+	QProcessEnvironment buildCleanEnvironment();
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.cpp b/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.cpp
new file mode 100644
index 0000000000..b13b8d7ece
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.cpp
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/services/RuntimeProbeTask.hpp"
+
+#include <QDebug>
+#include <QFile>
+#include <QFileInfo>
+#include <QMap>
+#include <utility>
+
+#include "Application.h"
+#include "Commandline.h"
+#include "FileSystem.h"
+#include "java/services/RuntimeEnvironment.hpp"
+
+namespace projt::java
+{
+	RuntimeProbeTask::RuntimeProbeTask(ProbeSettings settings) : Task(), m_settings(std::move(settings))
+	{}
+
+	QString RuntimeProbeTask::probeJarPath()
+	{
+		return APPLICATION->getJarPath("JavaCheck.jar");
+	}
+
+	void RuntimeProbeTask::executeTask()
+	{
+		QString checkerJar = probeJarPath();
+
+		if (checkerJar.isEmpty())
+		{
+			qDebug() << "Java checker library could not be found. Please check your installation.";
+			ProbeReport report;
+			report.path	  = m_settings.binaryPath;
+			report.token  = m_settings.token;
+			report.status = ProbeReport::Status::Errored;
+			emit probeFinished(report);
+			emitSucceeded();
+			return;
+		}
+#ifdef Q_OS_WIN
+		checkerJar = FS::getPathNameInLocal8bit(checkerJar);
+#endif
+
+		QStringList args;
+		process.reset(new QProcess());
+		if (!m_settings.extraArgs.isEmpty())
+		{
+			args.append(Commandline::splitArgs(m_settings.extraArgs));
+		}
+		if (m_settings.minMem != 0)
+		{
+			args << QString("-Xms%1m").arg(m_settings.minMem);
+		}
+		if (m_settings.maxMem != 0)
+		{
+			args << QString("-Xmx%1m").arg(m_settings.maxMem);
+		}
+		if (m_settings.permGen != 64 && m_settings.permGen != 0)
+		{
+			args << QString("-XX:PermSize=%1m").arg(m_settings.permGen);
+		}
+
+		args.append({ "-jar", checkerJar, "--list", "os.arch", "java.version", "java.vendor" });
+		process->setArguments(args);
+		process->setProgram(m_settings.binaryPath);
+		process->setProcessChannelMode(QProcess::SeparateChannels);
+		process->setProcessEnvironment(buildCleanEnvironment());
+		qDebug() << "Running runtime probe:" << m_settings.binaryPath << args.join(" ");
+
+		connect(process.get(), &QProcess::finished, this, &RuntimeProbeTask::finished);
+		connect(process.get(), &QProcess::errorOccurred, this, &RuntimeProbeTask::error);
+		connect(process.get(), &QProcess::readyReadStandardOutput, this, &RuntimeProbeTask::stdoutReady);
+		connect(process.get(), &QProcess::readyReadStandardError, this, &RuntimeProbeTask::stderrReady);
+		connect(&killTimer, &QTimer::timeout, this, &RuntimeProbeTask::timeout);
+		killTimer.setSingleShot(true);
+		killTimer.start(15000);
+		process->start();
+	}
+
+	void RuntimeProbeTask::stdoutReady()
+	{
+		QByteArray data = process->readAllStandardOutput();
+		QString added	= QString::fromLocal8Bit(data);
+		added.remove('\r');
+		m_stdout += added;
+	}
+
+	void RuntimeProbeTask::stderrReady()
+	{
+		QByteArray data = process->readAllStandardError();
+		QString added	= QString::fromLocal8Bit(data);
+		added.remove('\r');
+		m_stderr += added;
+	}
+
+	void RuntimeProbeTask::finished(int exitcode, QProcess::ExitStatus status)
+	{
+		killTimer.stop();
+		QProcessPtr activeProcess = process;
+		process.reset();
+
+		ProbeReport report;
+		report.path		 = m_settings.binaryPath;
+		report.token	 = m_settings.token;
+		report.stderrLog = m_stderr;
+		report.stdoutLog = m_stdout;
+		qDebug() << "STDOUT" << m_stdout;
+		if (!m_stderr.isEmpty())
+		{
+			qWarning() << "STDERR" << m_stderr;
+		}
+		qDebug() << "Runtime probe finished with status" << status << "exit code" << exitcode;
+
+		if (status == QProcess::CrashExit)
+		{
+			report.status = ProbeReport::Status::Errored;
+			emit probeFinished(report);
+			emitSucceeded();
+			return;
+		}
+
+		auto parseBlocks = [](const QString& stdoutText)
+		{
+			QList<QMap<QString, QString>> blocks;
+			QMap<QString, QString> current;
+			const auto lines = stdoutText.split('\n');
+			for (QString line : lines)
+			{
+				line = line.trimmed();
+				if (line.isEmpty())
+				{
+					if (!current.isEmpty())
+					{
+						blocks.append(current);
+						current.clear();
+					}
+					continue;
+				}
+				if (line.contains("/bedrock/strata"))
+				{
+					continue;
+				}
+				const auto eq = line.indexOf('=');
+				if (eq <= 0)
+				{
+					continue;
+				}
+				const auto key	 = line.left(eq).trimmed();
+				const auto value = line.mid(eq + 1).trimmed();
+				if (!key.isEmpty() && !value.isEmpty())
+				{
+					current.insert(key, value);
+				}
+			}
+			if (!current.isEmpty())
+			{
+				blocks.append(current);
+			}
+			return blocks;
+		};
+
+		auto resolvePath = [](const QString& path)
+		{
+			if (path.isEmpty())
+			{
+				return QString();
+			}
+			auto resolved  = FS::ResolveExecutable(path);
+			QString chosen = resolved.isEmpty() ? path : resolved;
+			QFileInfo info(chosen);
+			if (info.exists())
+			{
+				return info.canonicalFilePath();
+			}
+			return chosen;
+		};
+
+		auto matchesProbeTarget = [](const QString& targetPath, const QString& candidatePath)
+		{
+			if (targetPath.isEmpty() || candidatePath.isEmpty())
+			{
+				return false;
+			}
+			if (candidatePath == targetPath)
+			{
+				return true;
+			}
+#ifdef Q_OS_WIN
+			const QFileInfo targetInfo(targetPath);
+			const QFileInfo candidateInfo(candidatePath);
+			auto normalizeJavaName = [](QString fileName)
+			{
+				fileName = fileName.toLower();
+				if (fileName == "javaw.exe")
+				{
+					return QStringLiteral("java.exe");
+				}
+				return fileName;
+			};
+
+			return targetInfo.absolutePath().compare(candidateInfo.absolutePath(), Qt::CaseInsensitive) == 0
+				&& normalizeJavaName(targetInfo.fileName()) == normalizeJavaName(candidateInfo.fileName());
+#else
+			return false;
+#endif
+		};
+
+		const auto targetPath = resolvePath(m_settings.binaryPath);
+		QMap<QString, QString> results;
+		auto blocks = parseBlocks(m_stdout);
+		for (const auto& block : blocks)
+		{
+			const auto candidatePath = resolvePath(block.value("java.path"));
+			if (matchesProbeTarget(targetPath, candidatePath))
+			{
+				results = block;
+				break;
+			}
+		}
+		if (results.isEmpty() && !blocks.isEmpty() && targetPath.isEmpty())
+		{
+			results = blocks.first();
+		}
+
+		if (results.isEmpty() || !results.contains("os.arch") || !results.contains("java.version")
+			|| !results.contains("java.vendor"))
+		{
+			report.status = ProbeReport::Status::InvalidData;
+			emit probeFinished(report);
+			emitSucceeded();
+			return;
+		}
+
+		auto osArch		 = results["os.arch"];
+		auto javaVersion = results["java.version"];
+		auto javaVendor	 = results["java.vendor"];
+		bool is64 = osArch == "x86_64" || osArch == "amd64" || osArch == "aarch64" || osArch == "arm64"
+					|| osArch == "riscv64" || osArch == "ppc64le" || osArch == "ppc64";
+
+		report.status		= ProbeReport::Status::Valid;
+		report.is_64bit		= is64;
+		report.platformTag	= is64 ? "64" : "32";
+		report.platformArch = osArch;
+		report.version		= javaVersion;
+		report.vendor		= javaVendor;
+		qDebug() << "Runtime probe succeeded.";
+		emit probeFinished(report);
+		emitSucceeded();
+	}
+
+	void RuntimeProbeTask::error(QProcess::ProcessError err)
+	{
+		if (err == QProcess::FailedToStart)
+		{
+			qDebug() << "Runtime probe failed to start.";
+			qDebug() << "Process environment:";
+			qDebug() << process->environment();
+			qDebug() << "Native environment:";
+			qDebug() << QProcessEnvironment::systemEnvironment().toStringList();
+			killTimer.stop();
+			ProbeReport report;
+			report.path	 = m_settings.binaryPath;
+			report.token = m_settings.token;
+			emit probeFinished(report);
+		}
+		emitSucceeded();
+	}
+
+	void RuntimeProbeTask::timeout()
+	{
+		if (process)
+		{
+			qDebug() << "Runtime probe has been killed by timeout.";
+			process->kill();
+		}
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.hpp b/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.hpp
new file mode 100644
index 0000000000..c2b78a4c57
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeProbeTask.hpp
@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QProcess>
+#include <QTimer>
+
+#include "QObjectPtr.h"
+#include "java/core/RuntimeVersion.hpp"
+#include "tasks/Task.h"
+
+namespace projt::java
+{
+	class RuntimeProbeTask : public Task
+	{
+		Q_OBJECT
+	  public:
+		using QProcessPtr = shared_qobject_ptr<QProcess>;
+		using Ptr		  = shared_qobject_ptr<RuntimeProbeTask>;
+
+		struct ProbeSettings
+		{
+			QString binaryPath;
+			QString extraArgs;
+			int minMem	= 0;
+			int maxMem	= 0;
+			int permGen = 0;
+			int token	= 0;
+		};
+
+		struct ProbeReport
+		{
+			QString path;
+			int token = 0;
+			QString platformTag;
+			QString platformArch;
+			RuntimeVersion version;
+			QString vendor;
+			QString stdoutLog;
+			QString stderrLog;
+			bool is_64bit = false;
+			enum class Status
+			{
+				Errored,
+				InvalidData,
+				Valid
+			} status = Status::Errored;
+		};
+
+		explicit RuntimeProbeTask(ProbeSettings settings);
+
+		static QString probeJarPath();
+
+	  signals:
+		void probeFinished(const ProbeReport& report);
+
+	  protected:
+		void executeTask() override;
+
+	  private:
+		QProcessPtr process;
+		QTimer killTimer;
+		QString m_stdout;
+		QString m_stderr;
+
+		ProbeSettings m_settings;
+
+	  private slots:
+		void timeout();
+		void finished(int exitcode, QProcess::ExitStatus status);
+		void error(QProcess::ProcessError err);
+		void stdoutReady();
+		void stderrReady();
+	};
+} // namespace projt::java
\ No newline at end of file
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeScanner.cpp b/archived/projt-launcher/launcher/java/services/RuntimeScanner.cpp
new file mode 100644
index 0000000000..5aed027d78
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeScanner.cpp
@@ -0,0 +1,441 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "java/services/RuntimeScanner.hpp"
+
+#include <QDir>
+#include <QFileInfo>
+#include <QProcessEnvironment>
+#include <QStandardPaths>
+#include <functional>
+#include <vector>
+
+#include "Application.h"
+#include "FileSystem.h"
+
+namespace projt::java
+{
+	static QStringList resolveExecutables(const QStringList& candidates)
+	{
+		QStringList resolved;
+		resolved.reserve(candidates.size());
+		for (const auto& candidate : candidates)
+		{
+			if (candidate.isEmpty())
+			{
+				continue;
+			}
+			if (QDir::isRelativePath(candidate))
+			{
+				const auto found = QStandardPaths::findExecutable(candidate);
+				if (!found.isEmpty())
+				{
+					resolved.append(QFileInfo(found).canonicalFilePath());
+				}
+				continue;
+			}
+			const QFileInfo info(candidate);
+			if (info.exists() && info.isFile())
+			{
+				resolved.append(info.canonicalFilePath());
+			}
+		}
+		resolved.removeDuplicates();
+		return resolved;
+	}
+
+	QString RuntimeScanner::executableName()
+	{
+#if defined(Q_OS_WIN32)
+		return QStringLiteral("javaw.exe");
+#else
+		return QStringLiteral("java");
+#endif
+	}
+
+	QStringList RuntimeScanner::appendEnvPaths(const QStringList& base) const
+	{
+		QStringList expanded = base;
+		auto env			 = qEnvironmentVariable("PROJTLAUNCHER_JAVA_PATHS");
+#if defined(Q_OS_WIN32)
+		QStringList javaPaths = env.replace("\\", "/").split(QLatin1String(";"), Qt::SkipEmptyParts);
+
+		auto envPath			= qEnvironmentVariable("PATH");
+		QStringList pathEntries = envPath.replace("\\", "/").split(QLatin1String(";"), Qt::SkipEmptyParts);
+		for (const QString& entry : pathEntries)
+		{
+			javaPaths.append(entry + "/" + executableName());
+		}
+#else
+		QStringList javaPaths = env.split(QLatin1String(":"), Qt::SkipEmptyParts);
+#endif
+		for (const QString& entry : javaPaths)
+		{
+			expanded.append(entry);
+		}
+		return expanded;
+	}
+
+#if defined(Q_OS_WIN32)
+	QStringList RuntimeScanner::collectRegistryPaths(DWORD keyType,
+													 const QString& keyName,
+													 const QString& valueName,
+													 const QString& suffix) const
+	{
+		QStringList entries;
+
+		for (HKEY baseRegistry : { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE })
+		{
+			HKEY rootKey;
+			if (RegOpenKeyExW(baseRegistry,
+							  keyName.toStdWString().c_str(),
+							  0,
+							  KEY_READ | keyType | KEY_ENUMERATE_SUB_KEYS,
+							  &rootKey)
+				!= ERROR_SUCCESS)
+			{
+				continue;
+			}
+
+			DWORD subKeyCount = 0;
+			RegQueryInfoKeyW(rootKey, NULL, NULL, NULL, &subKeyCount, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+			if (subKeyCount > 0)
+			{
+				for (DWORD i = 0; i < subKeyCount; i++)
+				{
+					WCHAR subKeyName[255];
+					DWORD subKeyNameSize = 255;
+					auto retCode = RegEnumKeyExW(rootKey, i, subKeyName, &subKeyNameSize, NULL, NULL, NULL, NULL);
+					if (retCode != ERROR_SUCCESS)
+					{
+						continue;
+					}
+
+					QString versionKey = keyName + "\\" + QString::fromWCharArray(subKeyName) + suffix;
+					HKEY versionHandle;
+					if (RegOpenKeyExW(baseRegistry,
+									  versionKey.toStdWString().c_str(),
+									  0,
+									  KEY_READ | keyType,
+									  &versionHandle)
+						!= ERROR_SUCCESS)
+					{
+						continue;
+					}
+
+					DWORD valueSize = 0;
+					if (RegQueryValueExW(versionHandle, valueName.toStdWString().c_str(), NULL, NULL, NULL, &valueSize)
+						== ERROR_SUCCESS)
+					{
+						std::vector<WCHAR> buffer(valueSize / sizeof(WCHAR) + 1, 0);
+						RegQueryValueExW(versionHandle,
+										 valueName.toStdWString().c_str(),
+										 NULL,
+										 NULL,
+										 reinterpret_cast<BYTE*>(buffer.data()),
+										 &valueSize);
+						QString javaHome = QString::fromWCharArray(buffer.data());
+						QString javaPath = QDir(FS::PathCombine(javaHome, "bin")).absoluteFilePath(executableName());
+						entries.append(javaPath);
+					}
+					RegCloseKey(versionHandle);
+				}
+			}
+
+			RegCloseKey(rootKey);
+		}
+		return entries;
+	}
+#endif
+
+	QStringList RuntimeScanner::collectManagedBundles()
+	{
+		QStringList bundles;
+
+		auto addBundlePaths = [&bundles](const QString& prefix)
+		{
+			bundles.append(FS::PathCombine(prefix, "jre", "bin", RuntimeScanner::executableName()));
+			bundles.append(FS::PathCombine(prefix, "bin", RuntimeScanner::executableName()));
+			bundles.append(FS::PathCombine(prefix, RuntimeScanner::executableName()));
+		};
+
+		auto scanJavaDir = [&addBundlePaths](const QString& dirPath)
+		{
+			QDir dir(dirPath);
+			if (!dir.exists())
+			{
+				return;
+			}
+			auto entries = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+			for (const auto& entry : entries)
+			{
+				addBundlePaths(entry.canonicalFilePath());
+			}
+		};
+
+		scanJavaDir(APPLICATION->javaPath());
+
+		return bundles;
+	}
+
+	QStringList RuntimeScanner::collectMinecraftBundles()
+	{
+		QStringList processPaths;
+#if defined(Q_OS_MACOS)
+		processPaths << FS::PathCombine(QDir::homePath(),
+										FS::PathCombine("Library", "Application Support", "minecraft", "runtime"));
+#elif defined(Q_OS_WIN32)
+		auto appDataPath = QProcessEnvironment::systemEnvironment().value("APPDATA", "");
+		processPaths << FS::PathCombine(QFileInfo(appDataPath).absoluteFilePath(), ".minecraft", "runtime");
+
+		auto localAppDataPath	= QProcessEnvironment::systemEnvironment().value("LOCALAPPDATA", "");
+		auto minecraftStorePath = FS::PathCombine(QFileInfo(localAppDataPath).absoluteFilePath(),
+												  "Packages",
+												  "Microsoft.4297127D64EC6_8wekyb3d8bbwe");
+		processPaths << FS::PathCombine(minecraftStorePath, "LocalCache", "Local", "runtime");
+#else
+		processPaths << FS::PathCombine(QDir::homePath(), ".minecraft", "runtime");
+#endif
+
+		QStringList results;
+		while (!processPaths.isEmpty())
+		{
+			auto dirPath = processPaths.takeFirst();
+			QDir dir(dirPath);
+			if (!dir.exists())
+			{
+				continue;
+			}
+			auto entries  = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+			bool foundBin = false;
+			for (const auto& entry : entries)
+			{
+				if (entry.baseName() == "bin")
+				{
+					results.append(FS::PathCombine(entry.canonicalFilePath(), RuntimeScanner::executableName()));
+					foundBin = true;
+					break;
+				}
+			}
+			if (!foundBin)
+			{
+				for (const auto& entry : entries)
+				{
+					processPaths << entry.canonicalFilePath();
+				}
+			}
+		}
+		return results;
+	}
+
+	QStringList RuntimeScanner::collectPaths(bool managedOnly) const
+	{
+		QStringList candidates;
+		if (managedOnly)
+		{
+			candidates = collectManagedBundles();
+			return resolveExecutables(candidates);
+		}
+
+#if defined(Q_OS_WIN32)
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment", "JavaHome", ""));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\Java Development Kit", "JavaHome", ""));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Runtime Environment", "JavaHome", ""));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\Java Development Kit", "JavaHome", ""));
+
+		candidates.append(collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JRE", "JavaHome", ""));
+		candidates.append(collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\JavaSoft\\JDK", "JavaHome", ""));
+		candidates.append(collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JRE", "JavaHome", ""));
+		candidates.append(collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\JavaSoft\\JDK", "JavaHome", ""));
+
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JRE", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JRE", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\AdoptOpenJDK\\JDK", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\AdoptOpenJDK\\JDK", "Path", "\\hotspot\\MSI"));
+
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Eclipse Foundation\\JDK", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Eclipse Foundation\\JDK", "Path", "\\hotspot\\MSI"));
+
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Eclipse Adoptium\\JRE", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Eclipse Adoptium\\JRE", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Eclipse Adoptium\\JDK", "Path", "\\hotspot\\MSI"));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Eclipse Adoptium\\JDK", "Path", "\\hotspot\\MSI"));
+
+		candidates.append(collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Semeru\\JRE", "Path", "\\openj9\\MSI"));
+		candidates.append(collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Semeru\\JRE", "Path", "\\openj9\\MSI"));
+		candidates.append(collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Semeru\\JDK", "Path", "\\openj9\\MSI"));
+		candidates.append(collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Semeru\\JDK", "Path", "\\openj9\\MSI"));
+
+		candidates.append(collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Microsoft\\JDK", "Path", "\\hotspot\\MSI"));
+
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath", ""));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\Azul Systems\\Zulu", "InstallationPath", ""));
+
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_64KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath", ""));
+		candidates.append(
+			collectRegistryPaths(KEY_WOW64_32KEY, "SOFTWARE\\BellSoft\\Liberica", "InstallationPath", ""));
+
+		candidates.append("C:/Program Files/Java/jre8/bin/javaw.exe");
+		candidates.append("C:/Program Files/Java/jre7/bin/javaw.exe");
+		candidates.append("C:/Program Files/Java/jre6/bin/javaw.exe");
+		candidates.append("C:/Program Files (x86)/Java/jre8/bin/javaw.exe");
+		candidates.append("C:/Program Files (x86)/Java/jre7/bin/javaw.exe");
+		candidates.append("C:/Program Files (x86)/Java/jre6/bin/javaw.exe");
+
+		candidates.append("javaw");
+#elif defined(Q_OS_MAC)
+		candidates.append("java");
+		candidates.append(
+			"/Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/MacOS/itms/java/bin/java");
+		candidates.append("/Library/Internet Plug-Ins/JavaAppletPlugin.plugin/Contents/Home/bin/java");
+		candidates.append("/System/Library/Frameworks/JavaVM.framework/Versions/Current/Commands/java");
+
+		QDir libraryJVMDir("/Library/Java/JavaVirtualMachines/");
+		QStringList libraryJVMJavas = libraryJVMDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (const QString& java : libraryJVMJavas)
+		{
+			candidates.append(libraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/bin/java");
+			candidates.append(libraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/jre/bin/java");
+		}
+
+		QDir systemLibraryJVMDir("/System/Library/Java/JavaVirtualMachines/");
+		QStringList systemLibraryJVMJavas = systemLibraryJVMDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (const QString& java : systemLibraryJVMJavas)
+		{
+			candidates.append(systemLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/bin/java");
+			candidates.append(systemLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Commands/java");
+		}
+
+		auto home = qEnvironmentVariable("HOME");
+
+		QString sdkmanDir = qEnvironmentVariable("SDKMAN_DIR", FS::PathCombine(home, ".sdkman"));
+		QDir sdkmanJavaDir(FS::PathCombine(sdkmanDir, "candidates/java"));
+		QStringList sdkmanJavas = sdkmanJavaDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (const QString& java : sdkmanJavas)
+		{
+			candidates.append(sdkmanJavaDir.absolutePath() + "/" + java + "/bin/java");
+		}
+
+		QString asdfDataDir = qEnvironmentVariable("ASDF_DATA_DIR", FS::PathCombine(home, ".asdf"));
+		QDir asdfJavaDir(FS::PathCombine(asdfDataDir, "installs/java"));
+		QStringList asdfJavas = asdfJavaDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (const QString& java : asdfJavas)
+		{
+			candidates.append(asdfJavaDir.absolutePath() + "/" + java + "/bin/java");
+		}
+
+		QDir userLibraryJVMDir(FS::PathCombine(home, "Library/Java/JavaVirtualMachines/"));
+		QStringList userLibraryJVMJavas = userLibraryJVMDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+		for (const QString& java : userLibraryJVMJavas)
+		{
+			candidates.append(userLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/bin/java");
+			candidates.append(userLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Commands/java");
+		}
+#elif defined(Q_OS_LINUX) || defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)
+		candidates.append("java");
+		auto scanJavaDir =
+			[&candidates](
+				const QString& dirPath,
+				const std::function<bool(const QFileInfo&)>& filter = [](const QFileInfo&) { return true; })
+		{
+			QDir dir(dirPath);
+			if (!dir.exists())
+				return;
+			auto entries = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+			for (const auto& entry : entries)
+			{
+				if (!filter(entry))
+					continue;
+				QString prefix = entry.canonicalFilePath();
+				candidates.append(FS::PathCombine(prefix, "jre/bin/java"));
+				candidates.append(FS::PathCombine(prefix, "bin/java"));
+			}
+		};
+		auto snap		  = qEnvironmentVariable("SNAP");
+		auto scanJavaDirs = [scanJavaDir, snap](const QString& dirPath)
+		{
+			scanJavaDir(dirPath);
+			if (!snap.isNull())
+			{
+				scanJavaDir(snap + dirPath);
+			}
+		};
+#if defined(Q_OS_LINUX)
+		scanJavaDirs("/usr/java");
+		scanJavaDirs("/usr/lib/jvm");
+		scanJavaDirs("/usr/lib64/jvm");
+		scanJavaDirs("/usr/lib32/jvm");
+		auto gentooFilter = [](const QFileInfo& info)
+		{
+			QString fileName = info.fileName();
+			return fileName.startsWith("openjdk-") || fileName.startsWith("openj9-");
+		};
+		auto aoscFilter = [](const QFileInfo& info)
+		{
+			QString fileName = info.fileName();
+			return fileName == "java" || fileName.startsWith("java-");
+		};
+		scanJavaDir("/usr/lib64", gentooFilter);
+		scanJavaDir("/usr/lib", gentooFilter);
+		scanJavaDir("/opt", gentooFilter);
+		scanJavaDir("/usr/lib", aoscFilter);
+		scanJavaDirs("java");
+		scanJavaDirs("/opt/jdk");
+		scanJavaDirs("/opt/jdks");
+		scanJavaDirs("/opt/ibm");
+		scanJavaDirs("/app/jdk");
+#elif defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)
+		scanJavaDirs("/usr/local");
+#endif
+		auto home = qEnvironmentVariable("HOME");
+		scanJavaDirs(FS::PathCombine(home, ".jdks"));
+		QString sdkmanDir = qEnvironmentVariable("SDKMAN_DIR", FS::PathCombine(home, ".sdkman"));
+		scanJavaDirs(FS::PathCombine(sdkmanDir, "candidates/java"));
+		QString asdfDataDir = qEnvironmentVariable("ASDF_DATA_DIR", FS::PathCombine(home, ".asdf"));
+		scanJavaDirs(FS::PathCombine(asdfDataDir, "installs/java"));
+		scanJavaDirs(FS::PathCombine(home, ".gradle/jdks"));
+#else
+		candidates.append("java");
+#endif
+
+		candidates.append(collectMinecraftBundles());
+		candidates.append(collectManagedBundles());
+		candidates = appendEnvPaths(candidates);
+		return resolveExecutables(candidates);
+	}
+} // namespace projt::java
diff --git a/archived/projt-launcher/launcher/java/services/RuntimeScanner.hpp b/archived/projt-launcher/launcher/java/services/RuntimeScanner.hpp
new file mode 100644
index 0000000000..09000c914d
--- /dev/null
+++ b/archived/projt-launcher/launcher/java/services/RuntimeScanner.hpp
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-FileCopyrightText: 2026 Project Tick
+// SPDX-FileContributor: Project Tick Team
+/*
+ *  ProjT Launcher - Minecraft Launcher
+ *  Copyright (C) 2026 Project Tick
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+#pragma once
+
+#include <QStringList>
+
+#if defined(Q_OS_WIN32)
+#include <windows.h>
+#endif
+
+namespace projt::java
+{
+	class RuntimeScanner
+	{
+	  public:
+		RuntimeScanner() = default;
+
+		QStringList collectPaths(bool managedOnly) const;
+
+		static QString executableName();
+		static QStringList collectManagedBundles();
+		static QStringList collectMinecraftBundles();
+
+	  private:
+		QStringList appendEnvPaths(const QStringList& base) const;
+
+#if defined(Q_OS_WIN32)
+		QStringList collectRegistryPaths(DWORD keyType,
+										 const QString& keyName,
+										 const QString& valueName,
+										 const QString& suffix) const;
+#endif
+	};
+} // namespace projt::java