WinNative × Aurora

PC Gaming on Android — tuned for mid-end devices, with Mali GPU support

A fork of WinNative that integrates the working parts of Aurora (Mali Vulkan sanitizer + auto-installer) and adds device-tier-aware performance tuning so mid-end hardware (Snapdragon 7xx, Mali Valhall, 6–8 GB RAM) runs PC games at playable framerates without manual tweaking.

---

Why this fork exists

WinNative is the best-engineered Winlator derivative today — modular code, Rust Steam client, NTSync, Proton 9.0, proper CI, real signing. But it has no Mali GPU support: the Mali Vulkan driver crashes on >4 descriptor sets and on certain extensions that DXVK requests by default.

Aurora pioneered a Vulkan sanitizer layer that fixes this — but Aurora ships on top of GameNative, an older/flatter codebase with no NTSync, no Rust Steam client, weaker CI, and no release signing.

This fork takes the best of both:

From WinNative	From Aurora (with audit fixes)
Modular feature/ + runtime/ architecture	Mali Vulkan Sanitizer (5 rules + B4/B6 fixes)
Rust wn-steam-client (22K LOC)	Auto-installer for VC++/DirectX/PhysX/.NET
NTSync auto-detection	Per-game shader cache
Proton 9.0 container patterns	Immortalis GPU detection
3-flavor CI matrix with signing	DXVK_CONFIG fallback when sanitizer .so absent
GPL-3.0 clean license

Dropped from Aurora (dead code per deep audit — see docs/AUDIT.md):

• Phase 1 AOT texture engine (no PC game ships .ktx2)
• Phase 2 mesh LOD engine (no PC game ships .obj)
• Phase 3 Markov prefetcher (no libaurora_prefetch.so exists)
• Phase 4 cloud shader sync (no backend)

What's new: device-tier tuning

The headline addition. Every game launch classifies the device as HIGH, MID, or LOW and applies tier-appropriate env-var presets via putIfAbsent (user overrides always win).

Tier	Hardware	What we change vs WinNative defaults
HIGH	Snapdragon 8 Gen 2+, Dimensity 9200+, Immortalis, 12 GB+ RAM	dxvk.useDescriptorIndexing=True, d3d11.maxFeatureLevel=12_0
MID	Snapdragon 7xx, Dimensity 7/8, Mali G610/G77/G78, 6–8 GB RAM	BOX64 STRONGMEM=2 BIGBLOCK=1 CALLRET=1 FASTNAN=1 FASTROUND=1 SAFEFLAGS=1; DXVK maxFeatureLevel=11_0 relaxedBarriers=True useDescriptorIndexing=False shaderUseSubgroupOps=False; MESA_SHADER_CACHE_MAX_SIZE=512MB; WINEESYNC=1
LOW	Snapdragon 4xx/6xx, Mali G52/G72, 4 GB RAM	All MID settings + STRONGMEM=3, maxFeatureLevel=10_0, usePipelineLibrary=False, 256 MB shader cache

Plus three independent helpers applied after tier presets:

• NTSyncHelper — auto-detects /dev/ntsync (Linux 6.14+) and switches from esync to NTSync for ~10–20% sync overhead reduction.
• MemoryBudgetHelper — caps DXVK pipeline cache by RAM (<6 GB → 512 MB, <4 GB → 256 MB, <4 GB → 128 MB) and disables PulseAudio on very low RAM.
• AuroraSanitizerHelper — last in the chain; appends Mali DXVK workarounds to whatever DXVK_CONFIG the prior steps produced.

Order at game launch (in GuestProgramLauncherComponent.execGuestProgram, after envVars.putAll(this.envVars)):

1. TierPresets.apply()         // sets mid-end Box64/DXVK/Wine defaults
2. NTSyncHelper.applyIfSupported()  // overrides esync if /dev/ntsync exists
3. MemoryBudgetHelper.apply()  // caps DXVK cache, disables PulseAudio on low RAM
4. AuroraSanitizerHelper.setupSanitizer()  // Mali layer + DXVK_CONFIG fallback

All wrapped in try/catch — Aurora helpers never block game launch.

Mali Vulkan Sanitizer

A Vulkan layer that sits between DXVK and the Mali driver. 5 rules:

1. Blacklist VK_EXT_descriptor_indexing (Mali crash)
2. Blacklist VK_EXT_fragment_density_map (Mali render corruption)
3. Blacklist VK_KHR_shader_subgroup (Mali silent wrong results)
4. Blacklist VK_EXT_graphics_pipeline_library (Mali driver bug)
5. Split vkCmdBindDescriptorSets at >4 sets (Mali hard crash)

The split (rule 5) has two correctness fixes vs the original Aurora code:

• B4 — dynamic offsets sliced correctly per chunk. Original Aurora dumped all N dynamic offsets on chunk 1 and zero on chunks 2+, causing silent wrong rendering for any draw using sets 4+ with dynamic UBO bindings. This fork adds hooks for vkCreateDescriptorSetLayout (caches per-layout dynamic count), vkAllocateDescriptorSets/vkFreeDescriptorSets (caches per-set count), and uses them in vkCmdBindDescriptorSets to slice pDynamicOffsets per chunk. Falls back to the old behavior if the cached total doesn't match the caller's count (fail-safe).
• B6 — device resolved per command buffer. Original Aurora hard-coded g_device_dispatch[0], which broke multi-device scenarios (VR, external GPU). This fork adds hooks for vkAllocateCommandBuffers/vkFreeCommandBuffers to maintain a VkCommandBuffer → VkDevice map.

Inherits from latest Aurora: B1 (layer name match), B2 (env var ordering), B3 (glibc compile via #ifdef __BIONIC__), B5 (thread-safe dispatch tables via std::shared_mutex), B9 (Immortalis detection).

Build

Requirements: Android Studio, JDK 17, NDK 27.3.13750724, CMake 3.22+, Rust toolchain with aarch64-linux-android target.

git clone --recurse-submodules https://github.com/boiniArun2006/WinNative.git
cd WinNative
rustup target add aarch64-linux-android
./gradlew assembleStandardDebug

APK at app/build/outputs/apk/standard/debug/standard.apk.

Three flavors:

• standard — com.winnative.cmod (vanilla side-loading)
• ludashi — com.ludashi.benchmark (Xiaomi/RedMagic Performance Mode trigger)
• pubg — com.tencent.ig (PUBG Mobile package name for anti-cheat compatibility)

CI builds all three on every PR and on every tag push. See .github/workflows/.

Install

1. Download the latest APK from Releases or Actions.
2. Enable "Install from unknown sources" for your browser/file manager.
3. Tap the APK to install.
4. Launch WinNative and wait for the initial ImageFS extraction (~860 MB extracted).
5. Add a game: pick a Windows .exe or sync your Steam/Epic/GOG library.

Verify Aurora is active

After launching a game, check logcat:

adb logcat -s AuroraDeviceTier AuroraTierPresets AuroraNTSync AuroraMemBudget AuroraSanitizer AuroraMaliSanitizer

You should see lines like:

AuroraDeviceTier: Device classified as MID
AuroraTierPresets: Applying MID tier presets for container 1
AuroraNTSync: NTSync support: true (device=/dev/ntsync)
AuroraNTSync: Enabling NTSync (kernel supports /dev/ntsync)
AuroraMemBudget: Device RAM: 6GB
AuroraSanitizer: Mali/Immortalis GPU detected: Mali-G610 — enabling sanitizer

On non-Mali GPUs, the sanitizer is skipped (returns false) and only tier presets + NTSync + memory budget apply.

Project layout

app/src/main/
├── app/                 ← Application class, DI, settings config
├── feature/             ← UI features (one dir per feature)
│   ├── leaderboard/     ← PerformanceRecorder + leaderboard upload
│   ├── library/         ← Game library UI + GameSettings
│   ├── settings/        ← Settings screens
│   ├── stores/          ← Steam, GOG, Epic integrations
│   └── sync/            ← Cloud save sync
├── runtime/             ← Emulator runtime
│   ├── aurora/          ← ★ NEW: Aurora modules (this fork)
│   │   ├── AuroraSanitizerHelper.kt
│   │   ├── DeviceTier.kt
│   │   ├── TierPresets.kt
│   │   ├── NTSyncHelper.kt
│   │   └── MemoryBudgetHelper.kt
│   ├── audio/           ← ALSA, MIDI, PulseAudio
│   ├── compat/          ← Box64, FEXCore, gamefixes, SteamBridge
│   ├── container/       ← Container, ContainerCreation, Shortcut
│   ├── content/         ← ContentsManager, AdrenotoolsManager
│   ├── display/         ← XServer, XEnvironment, ImageFs, renderer
│   ├── input/           ← Controls, rumble, gestures
│   ├── system/          ← GPUInformation, PerformanceRecorder
│   └── wine/            ← WineUtils, EnvVars, WineInfo
├── shared/              ← Shared utilities
├── sharedmemory/        ← SysV shared memory
├── cpp/                 ← Native code (12 subprojects)
│   ├── aurora_mali_sanitizer/  ← ★ NEW: Vulkan layer (this fork)
│   ├── adrenotools/     ← Adreno driver hot-swap (submodule)
│   ├── wn-steam-client/ ← Rust Steam protocol client
│   ├── wn-libsteamclient/ ← C++ libsteamclient.so replacement
│   └── ...              ← 8 other native subprojects
├── rust/                ← Rust utilities (wn-steam-tools)
└── res/                 ← Android resources (15 locales)

Documentation

• docs/AUDIT.md — Deep audit of original Aurora (16 bugs found, 9 dropped as dead code)
• docs/TIER_TUNING.md — Rationale for each tier preset
• docs/MALI_SANITIZER.md — How the Vulkan layer works, including B4/B6 fixes
• CHANGELOG.md — Release history
• CONTRIBUTING.md — How to contribute

Credits

This fork builds on the work of many people:

• WinNative by Xnick417x and contributors — the base
• Aurora by boiniArun2006 — the Mali sanitizer concept and audit fixes
• GameNative by utkarshdalal — predecessor to WinNative
• Winlator by brunodev85 — original Winlator
• Winlator Bionic by Pipetto-crypto — bionic variant
• Pluvia community — Steam/Epic/GOG integration foundations
• Box64 by ptitSeb — x86/x64 → ARM64 translator
• Wine / DXVK / VKD3D / Proton — the actual Windows compat layer
• mesa/Turnip — Adreno Vulkan driver
• meshoptimizer by Arseny Kapoulkine — used by original Aurora (not in this fork)
• Basis Universal by Binomial LLC — used by original Aurora (not in this fork)

License

GPL-3.0 — same as upstream WinNative. See LICENSE.

The Aurora modules added by this fork (app/src/main/runtime/aurora/ and app/src/main/cpp/aurora_mali_sanitizer/) are also GPL-3.0, consistent with the project license.

Contributing

See CONTRIBUTING.md. PRs welcome — CI runs on every push and gates merges.

Disclaimer

This project is for running legitimately-owned games on your own device. It does not include any game ROMs, copyrighted game files, or DRM circumvention. The Steam/Epic/GOG integrations require you to log in with your own account.