Lumine for Android

English | 简体中文

Lumine is a Clash-style local proxy / VPN client for Android built on the enimul Go core (formerly lumine). It runs as an Android VPNService (TUN) tunnel and forwards traffic locally with configurable splitting rules.

The UI is natively built with Kotlin + Jetpack Compose, following Material Design 3 with dynamic color support. The Go core is compiled by gomobile into a single AAR, so the app keeps a pure native interface with no embedded WebView. Lumine is the mobile-side companion of the SniShaper proxy project.

Looking for the desktop version? See SniShaper — a Windows / Linux proxy client with the same enimul-based routing ideas, plus a headless CLI variant.

• One-tap local proxy (TUN): Android VPNService tunnel, start / stop from the home screen with a single switch.
• Subscription management: import configs from a subscription URL, refresh them, and switch among Clash-style configs on the fly.
• Rule engine: dedicated pages to view, create and edit domain and IP / CIDR rules with multiple proxy modes.
• Intelligent splitting: blacklist-driven routing based on GFWList, inherited from the enimul core, plus a flexible Fake-IP implementation.
• Real-time logs: level filtering (all / info / error / debug / other), auto-scroll tail, capture toggle and one-tap export.
• Global settings: upstream DNS address and core log level.
• Background keep-alive: guided setup for accessibility service, auto-start, battery optimization and more on common OEM ROMs.
• Material Design 3 UI: dynamic color from the system wallpaper on Android 12+ with a full baseline fallback, light / dark both supported.

Download the latest release APK that matches your device ABI, then install it (allow "install from unknown sources" when prompted):

Package id: com.moi.lumine.

1. Open the app and go to 配置订阅 / Subscription.
2. Add a subscription name and its URL, wait for the import to finish, then tap the config to apply it.
3. Return to the home screen and flip the switch to start the proxy — the tunnel icon appears once VPNService is running.
4. Fine-tune behavior on the Rules page, and check Keep-alive on OEM ROMs if the process gets killed after swiping the app away.

adb install -r app-arm64-v8a-debug.apk   # or any ABI split that matches
adb shell am start -n com.moi.lumine/.MainActivity

• Upstream core (enimul) — learn the proxying modes and the config file syntax (kept compatible with upstream).
• Desktop counterpart (SniShaper) — Windows / Linux GUI and headless CLI sharing similar routing concepts.
• Issues / FAQ — report unstable sites or ask for help.

The repository is split into an Android application and a Go core module. The Go core is bound to Android via gomobile and shipped as an AAR under android/app/libs/.

android/            Android app (Kotlin + Jetpack Compose, Material 3)
  app/src/main/       application code, screens and theme
  app/libs/           LumineCore.aar (Go core, generated)
enimul/             Go core: proxying & routing (gomobile bind entry: ./mobile)
tun2socks/          Go modules for tunnel / forwarding support
scripts/            build-android.ps1, gomobile-bind.ps1
fastlane/           store metadata (F-Droid / Play)
Makefile            make android -> android/app/libs/LumineCore.aar

git clone https://github.com/SniShaper/lumine-for-android
cd lumine-for-android/android

# Debug build
./gradlew assembleDebug

# Release build (signed when ANDROID_KEYSTORE_* env vars are provided)
./gradlew assembleRelease

On Windows use gradlew.bat instead of ./gradlew.

Requires a Go toolchain, gomobile, the Android SDK and an NDK:

go install golang.org/x/mobile/cmd/gomobile@latest
gomobile init

# Repository root
make android

make android wraps scripts/gomobile-bind.ps1 (bind enimul/mobile with -target=android -androidapi 24 and write LumineCore.aar).

• JDK 17+ (CI uses Temurin 21)
• Android SDK: compileSdk 36, targetSdk 36, minSdk 24 (Android 7.0+)
• Android NDK (release CI pins 30.0.14904198) and Build Tools 36.0.0
• Go toolchain (version pinned by enimul/go.mod, currently Go 1.26) + golang.org/x/mobile/cmd/gomobile

• android-release.yml — triggered on pushes to main / version tags and manual dispatch. It sets up Go + Android SDK + NDK, rebuilds LumineCore.aar with gomobile, runs assembleRelease, uploads the four ABI APKs as workflow artifacts, and on tag pushes creates / updates a GitHub Release with assets renamed as lumine-<tag>-app-<abi>-release.apk.
• fastlane.yml — validates the fastlane/ supply metadata on push / PR touching it.

• The Android app targets Android 7.0 (API 24) and above; release builds are split per ABI to keep each APK small.
• Debug builds ship arm64-v8a only; install a matching split (or rebuild for your emulator's ABI).
• The repository is not the official upstream enimul repository — it is an Android-focused adaptation. Some modes may behave unstably on certain sites; feedback is welcome.

This project benefits from the following open-source projects:

• enimul — Go proxying / routing core (upstream)
• lumine — the original project enimul was forked from
• SniShaper — desktop counterpart sharing the same design ideas

Lumine is developed as part of the SniShaper project family (SniShaperTeam). Thanks to everyone who contributed to this repository:

GNU Affero General Public License v3.0 (AGPL-3.0).