Native Droid Games

Android 17 preview raises the memory limits for games

Tue, 13 Oct 2026 09:00:00 +0000

The per-app limit on low-memory devices moves from 512 MB to 768 MB. The OOM killer still ignores your intent, and that is the part that matters. The Android 17 developer preview raises the per-app memory ceiling on devices with 4 GB of RAM from 512 MB to 768 MB, and makes the value readable through the activity manager. For a game with a large texture set this is real headroom, but it arrives with a condition: the limit is a ceiling, not a reservation.

NDK r29 preview: what changes for game builds

Tue, 22 Sep 2026 09:00:00 +0000

The preview drops the legacy toolchain files, moves to LLVM 19 and finally makes the C++ standard library choice explicit. The r29 preview removes the legacy android.toolchain.cmake path. Projects still setting ANDROID_NDK_TOOLCHAIN_VERSION will fail at configure time with a message that names the removed variable, which is better than the silent fallback older releases used.

The average frame is fine and the game still stutters

Tue, 18 Aug 2026 09:00:00 +0000

Report the 95th and 99th percentile, not the mean. A 16.6 ms average with a 40 ms tail is a game that hitches twice a second. A frame time average hides exactly the frames players notice. We logged a session with a mean of 16.4 ms and a 99th percentile of 48 ms: at 60 fps that is one visible hitch every 50 frames, which reads as “not smooth” even though every benchmark summary says otherwise.

The asset half of APK size

Tue, 21 Jul 2026 09:00:00 +0000

Compression settings saved 12 MB. Wrong texture formats saved 180 MB. The order matters. We took a 410 MB game build and looked at where the bytes were: textures 268 MB, audio 74 MB, meshes 31 MB, code 22 MB, everything else 15 MB. Changing compression on the APK moved the download by 12 MB. Changing the texture format moved it by 180 MB.

Gamepad to photon: measuring input latency end to end

Tue, 09 Jun 2026 09:00:00 +0000

A high-speed camera and a Bluetooth controller with a known LED give a number you can act on, without special hardware. We measured input latency by filming the controller's LED and the phone screen at 240 fps, then counting frames between the LED changing and the first pixel of the response. The method is crude but repeatable, and it separates transport latency from render latency.

The memory type you pick is a promise about the next frame

Tue, 28 Apr 2026 09:00:00 +0000

DEVICE_LOCAL is not automatically faster, and HOST_VISIBLE is not automatically slow. The difference shows up two frames later. A common pattern is to allocate every buffer as device-local and every staging buffer as host-visible, which is correct on desktop and leaves performance on the table on mobile. Mobile GPUs often share physical memory with the CPU, and a host-visible buffer that is also device-local avoids a copy at no cost.

Baseline profiles do not help native code, but their siblings do

Tue, 17 Mar 2026 09:00:00 +0000

A baseline profile speeds up the Java and Kotlin startup path. For a native game, the equivalent work happens in your own loader. Baseline profiles tell the Android runtime which classes to compile ahead of time. A game whose Java layer is a thin wrapper around NativeActivity will see almost no benefit, because there is almost nothing to compile.

The 16 KB page checklist, one year later

Tue, 24 Feb 2026 09:00:00 +0000

Most games are aligned now. The failures we still see are assets, not code: uncompressed files that get mapped directly. A year after the NDK default changed, the shared libraries in most reports are correctly aligned. The remaining failures are asset files: an uncompressed texture atlas or a custom pack file mapped with mmap must start at a 16 KB boundary, or the mapping silently falls back to a copy.

Three ways to compile shaders at load time, and what each costs

Wed, 14 Jan 2026 09:00:00 +0000

Offline, at install, or on first use. The trade-off is start-up time against a stutter you cannot hide. Vulkan requires pipeline state to be created before the first draw. A game can precompile everything offline into a pipeline cache, compile lazily on first use, or compile a small set during the loading screen.

Android 16 game mode: what the API actually reports

Wed, 12 Nov 2025 09:00:00 +0000

The mode is a request, not a guarantee. Here is what a game can read back, and which parts vary by device. Android 16 exposes a game mode through GameManager. A game can declare a preferred mode, read the current one, and register a callback for changes. The useful part for performance work is the callback: it fires when the system changes the mode because of thermals, battery saver or a user setting.

Thermal throttling on 2025 flagships: the first ten minutes

Tue, 30 Sep 2025 09:00:00 +0000

We ran the same scene for 40 minutes on six phones. Every one of them lost at least 20 percent of its frame rate, and two lost more than 40. The test scene is deliberately boring: a fixed camera, one directional light, one shadow cascade, and enough geometry to keep the GPU busy at 60 fps. We capped the frame rate at 60 and logged frame time, GPU frequency and battery temperature once per second.

Rust on Android: a toolchain that survives an NDK upgrade

Wed, 27 Aug 2025 09:00:00 +0000

Pin the target, the linker and the NDK version in one place, or spend a morning reading undefined symbol errors after every update. Rust support for Android targets is good enough for game code in 2025, but the setup is still three moving parts: the target triple, the linker that matches the NDK, and the C++ standard library that the linker pulls in for Vulkan and OpenSL wrappers.

Capturing a GPU frame on a retail phone without root

Tue, 15 Jul 2025 09:00:00 +0000

Debug layers plus a layer-enabled build are enough for most engines. The trick is getting the layer into the process before the first frame. A retail phone will not let you attach a GPU debugger to an arbitrary app, but it will load a Vulkan layer from your own APK if you package it and enable it from the app's own manifest. The layer writes a capture file that you copy off the device and open on a desktop.

NDK r28 makes 16 KB page alignment the default

Thu, 05 Jun 2025 09:00:00 +0000

Newer devices ship with 16 KB memory pages. Native libraries linked for 4 KB still load, but the gap is closing and the fix is one linker flag. NDK r28 links native libraries with 16 KB maximum page size by default. If you build with an older toolchain, add -Wl,-z,max-page-size=16384 to the linker flags and rebuild every shared object, including third-party .so files you did not compile yourself.

Oboe 1.9 cuts callback jitter on three of five test phones

Tue, 22 Apr 2025 09:00:00 +0000

The new version moves the resampler off the audio thread when the device runs at a non-native rate. The improvement is real but not universal. Oboe 1.9 changed how it handles a requested sample rate that differs from the device's native rate: the resampler now runs on a separate thread for streams opened in low-latency mode. We measured callback intervals on five phones with a 256-frame buffer at 48 kHz and a requested 44.1 kHz stream.

A missing image barrier that survived three releases

Tue, 18 Mar 2025 09:00:00 +0000

Sync validation found in four seconds what a month of playtesting could not: a writer and a reader touching the same image in the same submission. A small studio sent us a frame capture with a symptom we recognised: textures flickered for one frame after a level load, only on one GPU vendor, only when the frame rate was above 50. Nothing crashed, nothing logged, and the bug report had been open since November.