Zalith Launcher 2 for Android: Build and Architecture

Zalith Launcher 2's Android-specific role

Zalith Launcher 2 addresses a concrete problem: starting Minecraft: Java Edition from an Android device. It is not presented as a launcher for Bedrock Edition. The repository also explicitly distinguishes Zalith Launcher 2 from the older ZalithLauncher project, stating that the two are completely different despite their shared name.

The intended audience is people who want to use the Java Edition ecosystem on Android. The repository does not specify whether every launcher capability available on desktop is reproduced, so it would be an assumption to treat it as a complete desktop-launcher replacement. Its documented role is narrower. It packages an Android application around an existing launcher core and presents that core through an Android interface.

Kotlin is the primary language, while Jetpack Compose and Material Design 3 form the user interface stack. Those choices place the application within the native Android application model. The stated minimum API is 26, which excludes older Android releases, and the target API is 35. The README also lists ANGLE, LWJGL, `gl4es_extra_extra`, Fishnet, and several AndroidX, Kotlin, and Apache libraries. These dependencies indicate a combination of Android UI code and components related to graphics or Java game compatibility.

The project is a launcher, not a game modification or cheating tool. The README describes it as a launcher for Minecraft: Java Edition. It does not document account login, Microsoft authentication, modpack installation, Java-version selection, or offline play. Those are common launcher concerns, but the repository description and README do not establish whether such features are available in the current application.

PojavLauncher Core and Compose Interface

The clearest architectural fact is that Zalith Launcher 2 uses PojavLauncher as its launch core. The README links to the v3_openjdk Android JNI source tree in the PojavLauncher repository. That points to a hybrid design. Zalith Launcher 2 supplies an Android application and a Compose-based presentation layer while relying on Pojav-related code underneath for game-launch responsibilities.

This division lets the project build an Android application around an existing launcher engine rather than presenting every compatibility component as newly designed in this repository. It also creates a direct dependency on the behavior of that upstream core. The README does not document the boundary between Zalith-specific launch logic and upstream PojavLauncher code. It also does not explain how Java runtime files, renderer components, or native libraries are assembled for a release. Engineers evaluating changes would need to inspect those connections in the source.

The repository layout offers limited architectural clues. Top-level directories include `InputMap/`, `LWJGL/`, `LayerController/`, `Terracotta/`, `ColorPicker/`, `CardGrid/`, and `Guide/`. The Android application module is `ZalithLauncher/`. The presence of `InputMap/` fits the mobile launcher context, but the README does not define the runtime responsibilities of these directories or describe communication between them.

The interface technology is clearer. Jetpack Compose supplies composable Android UI elements, and Material Design 3 supplies the stated design system. The dependency notice includes Compose-related libraries such as `androidx-constraintlayout-compose`, `Coil Compose`, and `Coil Gifs`. This favors Android-native screens over a desktop interface placed inside a WebView, although the README does not explicitly rule out WebViews elsewhere in the application. It also does not provide screenshots or workflows that would permit a detailed interface assessment.

Building the Kotlin Project in Android Studio

The README provides developer build instructions, not an end-user installation guide. It does not state where users can download an APK, whether release assets contain signed Android packages, or how an application should be installed from source. Consequently, there is no documented end-user installation command to reproduce.

For development, the documented prerequisites are Android Studio Bumblebee or later, Android SDK minimum API 26, Android SDK target API 35, and JDK 11. The repository includes `gradlew` and `gradlew.bat`, but the README names no Gradle task for producing an APK. Its only documented shell command clones the repository over SSH:

git clone [email protected]:ZalithLauncher/ZalithLauncher2.git

A successful clone creates a local `ZalithLauncher2` directory containing the Gradle project. Open that directory in Android Studio and allow the IDE to configure it using the stated JDK 11 and Android SDK requirements. The repository does not identify a signing configuration, application ID, artifact filename, or output path.

The first source-build attempt should focus on configuration and compilation. Android Studio will report missing SDK, plugin, or dependency problems if its Gradle configuration cannot complete. If compilation succeeds, the next unverified step is package generation through Android Studio. Because the README names no exact task, menu path, or adb command, supplying one would invent a build workflow that the project has not documented.

Users also need an authenticated GitHub connection for the documented SSH clone command. The README does not offer an HTTPS alternative. That is a small but concrete setup constraint for developers who do not already have SSH access configured.

API Level, Packaging, and Device Constraints

The minimum API level of 26 is the clearest device constraint documented by the project. It excludes Android versions older than Android 8.0. The target API level is 35, but that describes the Android SDK target rather than a guarantee that every Android release or device can launch the game.

Actual operation also depends on processor architecture, graphics capabilities, storage, Android permissions, and the compatibility of the Java runtime. The README does not enumerate supported GPU paths, device models, or processor families. A Compose interface cannot resolve a renderer or Java runtime that fails on a particular device, so the documented API floor should not be treated as a complete compatibility statement.

The native side is especially relevant. The dependency table includes ANGLE, LWJGL, and `gl4es_extra_extra`, while the launch core comes from the referenced PojavLauncher v3_openjdk tree. The README does not explain which graphics backends are available, how Android OpenGL drivers are selected, or how unsupported configurations are detected. These are meaningful omissions for an engineer deciding whether the launcher will work on a specific phone or tablet.

Packaging is another documented gap. The README identifies `zalithlauncher.cn` as the project's website under construction and warns about an unrelated third-party site using the Zalith Launcher name. It does not identify that third-party site as a trusted download source. It also does not say whether the official homepage distributes signed APKs. A homepage alone therefore does not confirm an official binary distribution channel.

For a custom internal build, source access does not remove signing concerns. The repository documentation does not describe a keystore, release-signing process, reproducible build, or artifact checksum. Those items must be checked before distributing a custom package through a controlled channel.

PojavLauncher Compared with Zalith Launcher 2

PojavLauncher is both the architectural foundation of Zalith Launcher 2 and the closest relevant alternative identified by the README. The distinction is not that one project can launch Minecraft while the other cannot. Zalith Launcher 2 explicitly uses PojavLauncher's v3_openjdk Android JNI implementation as its launch core.

The difference presented by Zalith Launcher 2 is its own Android application design. Its primary language is Kotlin, and its interface uses Jetpack Compose with Material Design 3. A developer choosing Zalith Launcher 2 is therefore choosing that Compose application and its surrounding modules. A developer starting directly from PojavLauncher would remain closer to the upstream project named in the README.

The README does not provide enough information for a reliable feature-by-feature comparison. It lists no command-line options, renderer choices, Java runtime controls, or account workflows for either project. It also does not describe how Zalith Launcher 2 tracks changes in PojavLauncher upstream. Compatibility with a selected Minecraft version and a particular Android device should therefore be verified directly rather than inferred from the shared launch core.

For someone who only needs the documented PojavLauncher core, working with the referenced upstream tree can offer a more direct lineage. For someone who wants an Android-native Compose application around that core, Zalith Launcher 2 is the more relevant codebase. The present choice rests on packaging and integration needs, while launch compatibility still depends on the underlying PojavLauncher components.

GPL-3.0 Conditions and Upgrade Cost

Zalith Launcher 2 is licensed under GPL-3.0. The README records additional distribution terms tied to GPLv3 section 7. It states that a distributed modified version must have a changed name or version number so it cannot be confused with the original. The added wording says modified versions must not contain `ZalithLauncher` or the abbreviation `ZL`, or a similar name likely to cause confusion.

Modified distributions must also display an unofficial modified-version notice on the startup page or main interface. Copyright notices must remain in place. The README identifies `ZalithLauncher/gradle.properties` as the place where the application name can be changed. It describes these points as license obligations, but this review does not provide legal advice or interpret how the terms apply in a specific distribution.

The repository is not archived, and its last push was on 2026-10-16. Recent releases include 2.7 on 2026-10-11, 2.6.1 on 2026-09-28, and 2.6 on 2026-09-24. This history records recent project activity, but it does not establish how quickly individual Android devices, Minecraft versions, or account workflows receive support after an update.

Upgrade work can be substantial for a fork. Renaming the application, marking the modified build, preserving notices, and tracking changes in the PojavLauncher-derived core are part of preparing a compliant distribution. The dependency notice is also broad. Changes involving AndroidX, Compose, Coil, ANGLE, LWJGL, Fishnet, networking, or native launch components can require separate compatibility checks. The README does not publish an upgrade policy, support matrix, or migration guide.

Editorial conclusion

Android users who specifically need an Android launcher for Minecraft: Java Edition and are comfortable building the Kotlin project can assess Zalith Launcher 2. Desktop users and people seeking documented APK installation steps should choose another route. Before adoption, verify that PojavLauncher supplies every device, account, and rendering requirement needed, then confirm how a build is packaged and installed because the README does not document that path.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. README
4. Releases
5. ZalithLauncher/ZalithLauncher2 on GitHub