android-0.1.12-patch-fix

Fix for issue #24

BytArch GTA-V for Android 0.1.12-patch (game folder found, real heap limit)

BytArch GTA-V - the GTA V web port running natively on Android, ARM64 / Android 10+ / Vulkan.

BytArch-GTA-V-android-0.1.12-patch-debug.apk - debug build, sideload it over 0.1.11-patch.

This patch fixes the launcher not finding game data that is there, and it makes
the heap limit the engine is told match the limit the phone can actually give.

The game folder is now found inside the folder you pick

The release ships the game inside a wrapper folder:

GrandV-assets/
  START_HERE.txt
  grandv-assets.json
  mirror/playgta5.com/
    data/manifest.json
    b/<build>/shaders/index.json
    b/<build>/game.wasm

START_HERE.txt says to pick the GrandV-assets folder. The launcher only
accepted a folder with data/manifest.json directly in it, so following those
instructions produced "That folder has no data/manifest.json" - the file was
right there, two levels down.

The game folder is the one that holds data/ and b/<build>/, and the launcher
now looks for it inside whatever you picked (a few levels deep, without walking
the game tree). Picking GrandV-assets works, picking
GrandV-assets/mirror/playgta5.com works, and the folder the game is read
from is the same one the engine gets, so the game runs from your download
without a copy.

The same applies to Import game ZIP: a wrapper folder inside the archive is
stripped, so the release archive works as it is.

The heap limit is the real one now, and it shows in the log

The engine asks the host how much memory it may use, and it sizes its pools
from that answer. Two numbers have to agree: the limit the engine is told, and
the limit the phone can really give. They now do, and the log prints them:

[host] game module memory: initial 3072 MB, module maximum 16384 MB, Android cap 5120 MB
[host] engine asked for the heap maximum: 5368709120 bytes (5120 MB)

If the cap is too small for the settings you picked, the engine fills the
memory it was promised and the game dies with:

[host] thread 0x... trapped: ... emscripten_builtin_malloc
Caused by: wasm trap: out of bounds memory access

The heap setting in the launcher (Maximum game heap (not total app
memory)) is that cap: 3 GB to 8 GB, 5 GB by default. On a phone with 8 GB, 5 GB
works (measured on a Galaxy A34 5G). With 12 GB or more, 8 GB gives the engine
room for the higher graphics settings. Lower it if the phone is short on
memory - a smaller cap makes the engine plan for less instead of running out
halfway.

The 0.1.11-patch fixes stay in: the Adreno black screen (software clip
distance emulation), the compressed texture uploads, the renderer memory bound
and the reported GPU device loss.

What to test

1. Sideload this APK over 0.1.11-patch.
2. Point the app at the game: Use a game files folder and pick
   GrandV-assets (or the folder with data/ and b/ in it). The launcher
   should say Game folder: .../mirror/playgta5.com.
3. Set the heap in the launcher to what your phone can give (5 GB on 8 GB
   phones, 8 GB on 12 GB and up).
4. Play, and export the logs if anything goes wrong - the export now carries
   the heap limits the engine was given.

Getting game data in

The app ships no game content; you supply your own copy of the web port's data,
which must have this layout:

data/manifest.json
b/<build>/shaders/index.json
b/<build>/game.wasm        (native wasm2c engine only)

Two ways to point the app at it:

• Use a game files folder - pick a folder that already holds data/ and
  b/. Nothing is copied, so it works with no free space. The folder may have
  the game a few levels down, the launcher finds it.
• Import game ZIP - pick a .zip of the same tree. It is extracted into app
  storage, which needs free space for both the archive and the extracted data.

Whichever you choose, the folder must be on internal storage (/sdcard/...).
If the launcher says the folder cannot be read, tap Grant file access and
allow "All files access".

Graphics

Every knob the web launcher exposes is in the launcher, under Graphics,
with the same names: texture, reflection, water, particle and grass quality,
scenery/pedestrian/vehicle detail, city density, variety, post FX, motion blur,
depth of field, shadow quality and softness, ambient occlusion, render distance,
fog, particle and long shadows, loading ahead, and distant lights. Low (phone
default) turns shadows off entirely and pulls the render distance in.

Multiplayer

Multiplayer uses the Grand-V relay - the same transport as the web version, so
you can share a room with browser players. You need a relay address
(ws://host:8012/relay), a room name and the access code from whoever is
hosting. Rooms hold two players and carry pose only: position, rotation and
model. Plain ws:// for now, no TLS.

Known limits

• ARM64 only, Vulkan required, Android 10+.
• First launch compiles the game and takes several minutes; early stutter is
  mostly loading from storage.
• Signed with a debug key. Fine for sideloading, not for any store.
• This patch covers the Wasmtime engine. The native wasm2c engine button still
  boots and logs but does not render; use the wasmtime engine for gameplay.

Tested

Galaxy A34 5G (8 GB) with the Wasmtime engine: the game folder picked as
GrandV-assets, heap 5 GB.

BytArch GTA-V for Android 0.1.9-patch (Adreno black screen fixed)

BytArch GTA-V - the GTA V web port running natively on Android, ARM64 / Android 10+ / Vulkan.

BytArch-GTA-V-android-0.1.9-patch-debug.apk - debug build, sideload it over 0.1.8-patch.

This patch follows 0.1.8-patch and contains the fix for the black screen the
0.1.8-patch test found: the Adreno Vulkan driver loses the device when a
shader uses clip distances.

What the 0.1.8-patch test showed

The tester on a RedMagic 11 Pro (Adreno 840) reported:

Both checkboxes off: black screen;
"decode BC textures on CPU" on: black screen;
"software clip distances" on: game runs normally, 3D objects and textures are correct.

The new logs confirm the cause:

[wgpu] device lost: Unknown: Unexpected error variant (driver implementation is at fault)

The driver dies while the first pipelines are compiled, the Vulkan device is
gone, and everything after that is drawn into a dead device - which is the
black screen with the sound still playing. Clip distances are the only thing
that differs between the black run and the working one.

What this patch changes

• Clip distances are emulated in the fragment stage on Adreno devices. The
  renderer recognises an Adreno adapter and leaves the clip distances feature
  out for it, so the game never asks the driver for hardware clip distances.
  The picture is the same, the driver stays alive.
• The emulated clip varyings pick free locations, so they cannot collide
  with a varying of the game.
• The log line now says which path is in use:
  clip distances: software emulation (Adreno driver) or
  clip distances: hardware.

Other devices keep the hardware path, so nothing changes for them. The
launcher switch Force software clip distances still turns the emulation on
for any other device if it is needed.

The 0.1.8-patch fixes stay in: compressed textures are uploaded and copied in
whole blocks, the device loss is reported instead of failing silently, and the
failed pipeline is logged with its colour targets and depth format.

What to test

1. Sideload this APK over 0.1.8-patch.
2. Play with both switches off. On an Adreno device the log should say
   clip distances: software emulation (Adreno driver).
3. If it is still black, export the logs and attach them.

Getting game data in

The app ships no game content; you supply your own copy of the web port's data,
which must have this layout:

data/manifest.json
b/<build>/shaders/index.json
b/<build>/game.wasm        (native wasm2c engine only)

Two ways to point the app at it:

• Use a game files folder - pick a folder that already holds data/ and
  b/. Nothing is copied, so it works with no free space, and you can pick the
  parent folder if the data sits in a game/ subfolder.
• Import game ZIP - pick a .zip of the same tree; it is extracted into app
  storage, which needs free space for both the archive and the extracted data.

Whichever you choose, the folder must be on internal storage (/sdcard/...).
If the launcher says the folder cannot be read, tap Grant file access and
allow "All files access".

Graphics

Every knob the web launcher exposes is in the launcher, under Graphics,
with the same names: texture, reflection, water, particle and grass quality,
scenery/pedestrian/vehicle detail, city density, variety, post FX, motion blur,
depth of field, shadow quality and softness, ambient occlusion, render distance,
fog, particle and long shadows, loading ahead, and distant lights. Low (phone
default) turns shadows off entirely and pulls the render distance in.

Multiplayer

Multiplayer uses the Grand-V relay - the same transport as the web version, so
you can share a room with browser players. You need a relay address
(ws://host:8012/relay), a room name and the access code from whoever is
hosting. Rooms hold two players and carry pose only: position, rotation and
model. Plain ws:// for now, no TLS.

Known limits

• ARM64 only, Vulkan required, Android 10+.
• First launch compiles the game and takes several minutes; early stutter is
  mostly loading from storage.
• Signed with a debug key. Fine for sideloading, not for any store.
• This patch covers the Wasmtime engine. The native wasm2c engine button still
  boots and logs but does not render; use the wasmtime engine for gameplay.

Tested

Galaxy A34 5G (8 GB) with the Wasmtime engine.

BytArch GTA-V for Android 0.1.8-patch (Adreno black screen fix)

BytArch GTA-V - the GTA V web port running natively on Android, ARM64 / Android 10+ / Vulkan.

BytArch-GTA-V-android-0.1.8-patch-debug.apk - debug build, sideload it over 0.1.7.

This is a patch release for the Wasmtime engine and for the Adreno black-screen
reports: #6 (POCO F8 Ultra), #7 (OnePlus 15R) and #8 (RedMagic 11 Pro).

What the patch changes

• Compressed textures are uploaded and copied in whole blocks. D3D reports the
  logical mip size, so a 1x1 or 2x2 BC mip was copied as one texel while WebGPU
  copies 4x4 blocks. Every BC mip upload failed with Copy width is not a multiple of block width / Copy height is not a multiple of block height.
  That pair of errors is the first thing in the logs of all three reports.
• The software clip-distance fallback no longer drops the fragment shader
  body, and it now handles a fragment entry point without a return type.
• A lost GPU device is reported instead of failing silently. The logs now
  carry the GPU driver name, the pipeline that failed together with its colour
  targets and depth format, and the device-loss reason. The renderer stops
  submitting to a dead device and answers the engine's waits instead of failing
  them, so the log no longer fills up with destroyed readback buffers.
• Two diagnostics are in the launcher, under Graphics, for the Adreno
  specific paths: Wasmtime diagnostic: decode BC textures on CPU and
  Wasmtime diagnostic: software clip distances. Both are off by default; turn
  them on one at a time.

What to test

1. Sideload this APK over the old one.
2. Play with both diagnostics off, in the same game mode and with the same
   graphics settings as before.
3. If the world is still black, turn on decode BC textures on CPU, play, and
   export the logs. Then turn it off, turn on software clip distances, play,
   and export the logs again.
4. Send the logs back. They now name the driver, the failed pipeline and the
   device-loss reason, so one log is enough to place the failure.

Getting game data in

The app ships no game content; you supply your own copy of the web port's data,
which must have this layout:

data/manifest.json
b/<build>/shaders/index.json
b/<build>/game.wasm        (native wasm2c engine only)

Two ways to point the app at it:

• Use a game files folder - pick a folder that already holds data/ and
  b/. Nothing is copied, so it works with no free space, and you can pick the
  parent folder if the data sits in a game/ subfolder.
• Import game ZIP - pick a .zip of the same tree; it is extracted into app
  storage, which needs free space for both the archive and the extracted data.

Whichever you choose, the folder must be on internal storage (/sdcard/...).
If the launcher says the folder cannot be read, tap Grant file access and
allow "All files access".

Graphics

Every knob the web launcher exposes is in the launcher, under Graphics,
with the same names: texture, reflection, water, particle and grass quality,
scenery/pedestrian/vehicle detail, city density, variety, post FX, motion blur,
depth of field, shadow quality and softness, ambient occlusion, render distance,
fog, particle and long shadows, loading ahead, and distant lights. Low (phone
default) turns shadows off entirely and pulls the render distance in.

Multiplayer

Multiplayer uses the Grand-V relay - the same transport as the web version, so
you can share a room with browser players. You need a relay address
(ws://host:8012/relay), a room name and the access code from whoever is
hosting. Rooms hold two players and carry pose only: position, rotation and
model. Plain ws:// for now, no TLS.

Known limits

• ARM64 only, Vulkan required, Android 10+.
• First launch compiles the game and takes several minutes; early stutter is
  mostly loading from storage.
• Signed with a debug key. Fine for sideloading, not for any store.
• This patch covers the Wasmtime engine. The native wasm2c engine button still
  boots and logs but does not render; use the wasmtime engine for gameplay.

Tested

Galaxy A34 5G (8 GB) with the Wasmtime engine.

BytArch GTA-V for Android 0.1.7 (touch controls fixed, better GPU support)

The touch controls are back and the scene renders on more GPUs (issues #2 and #3).

app-debug.apk — arm64-v8a, Android 10+, debug signed.
SHA-256: 402c3e944d97f9ce1ca7ec18ba47b7c87532c1da36bd5fd819168481df4ee43c

What's in 0.1.7

• The touch controls show up again. The on-screen buttons live in their own
  window so they can sit on top of the game, and on some devices that window
  was refused or quietly lost, which left the player with gameplay but no
  controls and no explanation. It is now attached reliably, it comes back after
  the game is paused and resumed, and the launcher log records what happened so
  a report can say whether it worked.
• The scene renders properly on more phones. Some effects need a GPU
  feature that not every phone has. They are now handled in software instead of
  being dropped, so characters, vehicles, glass, water and the depth-of-field
  passes show up again on Mali-based devices.
• A controller with no axes no longer hides the touch controls, and the
  launcher log now says when the touch controls were switched off because a
  gamepad was detected.

Install

adb install -r over 0.1.6 — same signing key, so your settings carry over.

If the game still misbehaves, export the log from the launcher right away (its
tail is closest to the moment it happened) and attach it to the issue. The log
now also contains a short hud section describing the touch controls.

BytArch GTA-V for Android 0.1.6 (fixes the crash after the opening credits)

The crash after the opening credits is fixed (issue #2).

BytArch-GTA-V-android-0.1.6-debug.apk — arm64-v8a, Android 10+, debug signed.
SHA-256: af86faad1cef8f5d6d427d8f86cc7c49f6807c79434a25d5acd8a754eacb8b36

What's in 0.1.6

• Draws with an unbound render target are skipped instead of pushed through.
  A pixel shader that writes to a render target slot the pass does not bind is
  legal in D3D11 — the write is simply discarded — but WebGPU cannot express
  that. Building the pipeline anyway left an invalid pipeline in the command
  buffer, and using it made every later resource of that frame invalid: that is
  how one mismatched target turned into a dead occlusion readback and the crash
  in the log. Such draws are now skipped, the same way the browser build does.
  The log of a test run is now clean: no validation errors, no invalid
  pipelines, no invalid buffers.
• The renderer survives a refused readback. When the GPU refused a buffer
  mapping, the renderer panicked and the process died with it. It now reports
  the failure and answers the engine anyway, so a lost readback costs a frame
  instead of the game.

0.1.5 is broken - use this one

0.1.5 carried the first half of the fix but released the mapped view one line
too late, so the GPU thread panicked on unmap ("You cannot unmap a buffer that
still has accessible mapped views"). 0.1.6 fixes that too.

Everything from 0.1.4 still stands: the launcher exports its own logs, a picked
/sdcard game folder is readable, and the graphics knobs are unchanged.

Install

adb install -r over 0.1.4 or 0.1.5 — same signing key, so your settings carry
over.

If the game still misbehaves, export the log from the launcher right away (its
tail is closest to the moment it happened) and attach it to the issue.

BytArch GTA-V for Android 0.1.11-patch (app icon, new name, bug report links)

BytArch GTA-V - the GTA V web port running natively on Android, ARM64 / Android 10+ / Vulkan.

BytArch-GTA-V-android-0.1.11-patch-debug.apk - debug build, sideload it over 0.1.10-patch.

This patch follows 0.1.10-patch and is a launcher-only release: the engine is
untouched, and the memory fixes of 0.1.10-patch stay in.

What this patch changes

• The app has an icon. The launcher used to fall back to the default
  Android robot. It now ships the GTA V badge, as an adaptive icon on Android 8
  and newer and as plain launcher icons on older systems. The badge art came
  with a white and grey checkerboard baked into the pixels instead of real
  transparency, so the background was made transparent before it was cut into
  the launcher sizes.
• The app is called Grand V Android. The name under the icon, the launcher
  title and the dialogs read "Grand V Android" now instead of "GTA 5".
• The launcher text is readable again. A few strings in the launcher showed
  mangled characters (â€ where a dash should be, … where an ellipsis
  should be). Those five strings are fixed, the game itself was never affected.
• Bug reports have a home. Two buttons at the bottom of the launcher open
  the issue tracker on GitHub and the author on X (Twitter), so a broken build
  can be reported without looking for a mail address.

What to test

1. Sideload this APK over 0.1.10-patch.
2. Check the home screen: the icon should be the GTA V badge and the name
   under it "Grand V Android".
3. Open the launcher: the title must read "Grand V Android", and the text
   must show real dashes and dots.
4. Scroll to the bottom of the launcher and tap both new buttons. Each one
   should open the browser, on the GitHub issue tracker and on X.
5. Export the logs and attach them here if anything looks wrong.

Getting game data in

The app ships no game content; you supply your own copy of the web port's data,
which must have this layout:

data/manifest.json
b/<build>/shaders/index.json
b/<build>/game.wasm        (native wasm2c engine only)

Two ways to point the app at it:

• Use a game files folder - pick a folder that already holds data/ and
  b/. Nothing is copied, so it works with no free space, and you can pick the
  parent folder if the data sits in a game/ subfolder.
• Import game ZIP - pick a .zip of the same tree; it is extracted into app
  storage, which needs free space for both the archive and the extracted data.

Whichever you choose, the folder must be on internal storage (/sdcard/...).
If the launcher says the folder cannot be read, tap Grant file access and
allow "All files access".

Graphics

Every knob the web launcher exposes is in the launcher, under Graphics,
with the same names: texture, reflection, water, particle and grass quality,
scenery/pedestrian/vehicle detail, city density, variety, post FX, motion blur,
depth of field, shadow quality and softness, ambient occlusion, render distance,
fog, particle and long shadows, loading ahead, and distant lights. Low (phone
default) turns shadows off entirely and pulls the render distance in.

Multiplayer

Multiplayer uses the Grand-V relay - the same transport as the web version, so
you can share a room with browser players. You need a relay address
(ws://host:8012/relay), a room name and the access code from whoever is
hosting. Rooms hold two players and carry pose only: position, rotation and
model. Plain ws:// for now, no TLS.

Known limits

• ARM64 only, Vulkan required, Android 10+.
• First launch compiles the game and takes several minutes; early stutter is
  mostly loading from storage.
• Signed with a debug key. Fine for sideloading, not for any store.
• This patch covers the Wasmtime engine. The native wasm2c engine button still
  boots and logs but does not render; use the wasmtime engine for gameplay.
• A launcher that caches its icon keeps showing the old one until it is
  restarted or the icon cache is cleared.

Tested

Built by GitHub Actions on ubuntu-24.04: Rust unit tests, then Gradle
assembleDebug and testDebugUnitTest. The launcher changes still need a
look on a real phone - please report anything that looks wrong, with a log.

BytArch GTA-V for Android 0.1.10-patch (Maximum graphics memory fix)

BytArch GTA-V - the GTA V web port running natively on Android, ARM64 / Android 10+ / Vulkan.

BytArch-GTA-V-android-0.1.10-patch-debug.apk - debug build, sideload it over 0.1.9-patch.

This patch follows 0.1.9-patch and targets the crash the 0.1.9-patch test found at
the Maximum graphics setting.

What the 0.1.9-patch test showed

The tester on a RedMagic 11 Pro confirmed the black screen is gone ("everything
ok, game run normally without any checkboxes"), then reported a second problem:
with graphics set to Maximum the game crashes after a few minutes. The same
session at Low stays alive.

His 0.1.9 log shows the memory picture behind the crash:

low :  process RSS about 2.7 GB
max :  process RSS peaks at 4.15 GB, then the log ends
       a 256 MB region is allocated right before the end of the log
       engine malloc arena 2417 MB (in use 2382 MB)
       37982 live buffers, about 10000 textures
       bind groups cached: up to 28565

There is no kill reason in the log, so it is not yet known whether Android killed
the process for low memory or the engine died on its own. Two things were wrong
in any case, and both are fixed here.

What this patch changes

• Host buffer memory is bounded. The renderer kept a CPU copy ("shadow") of
  every buffer. The copy is now allocated only for the ranges that are really
  uploaded and never grows past the size the engine declared for the buffer,
  instead of following the allocator's capacity.
• The bind group cache is bounded. It was allowed to grow to 24000 entries
  and kept every entry alive. It now evicts the oldest entry when it is full,
  with a limit of 4096 on Android (24000 elsewhere), and reports the number of
  evictions.
• The engine's heap limit is enforced. emscripten_get_heap_max returned a
  hardcoded 16 GB, so the engine happily planned allocations the phone cannot
  give it, and the growth request could overshoot the cap. It now reports the
  real limit of the memory type (5 GB on Android by default) and refuses growth
  past it instead of asking for more and failing later.
• The log says where the memory goes. New lines:

  [host] heap: initial 2108 MB, maximum 5120 MB, page size 65536 bytes
  host buffer memory: shadow data 141312 KiB, allocated 157696 KiB, declared 131072 KiB; uniform staging 4096 KiB; bind group cache 4096/4096 (23847 evictions)
  

• The exit reason is exported with the logs. The launcher now appends
  Android's own record of how the game process ended:

  [android-exit] Recent game-process exits (system-reported):
  [android-exit] timestamp_ms=... reason=LOW_MEMORY importance=... pss_kb=...
  

  This is the piece that tells low-memory kill apart from a native crash. It
  needs Android 11 or newer; on older systems the log says so.

The 0.1.9-patch fix stays in: the Adreno black screen (software clip distance
emulation) and the compressed texture upload errors.

What to test

1. Sideload this APK over 0.1.9-patch.
2. Set graphics to Maximum - the setting that crashed.
3. Play for at least as long as it took to crash before (a few minutes).
4. Export the logs and attach them here, also if it crashes. The export now
   contains the [android-exit] section with the system's exit reason, so one
   log is enough to tell us what killed the game.

If Maximum still crashes, the exit reason in the log points straight at the
next step (lower default heap, or the exact allocation that fails).

Getting game data in

The app ships no game content; you supply your own copy of the web port's data,
which must have this layout:

data/manifest.json
b/<build>/shaders/index.json
b/<build>/game.wasm        (native wasm2c engine only)

Two ways to point the app at it:

• Use a game files folder - pick a folder that already holds data/ and
  b/. Nothing is copied, so it works with no free space, and you can pick the
  parent folder if the data sits in a game/ subfolder.
• Import game ZIP - pick a .zip of the same tree; it is extracted into app
  storage, which needs free space for both the archive and the extracted data.

Whichever you choose, the folder must be on internal storage (/sdcard/...).
If the launcher says the folder cannot be read, tap Grant file access and
allow "All files access".

Graphics

Every knob the web launcher exposes is in the launcher, under Graphics,
with the same names: texture, reflection, water, particle and grass quality,
scenery/pedestrian/vehicle detail, city density, variety, post FX, motion blur,
depth of field, shadow quality and softness, ambient occlusion, render distance,
fog, particle and long shadows, loading ahead, and distant lights. Low (phone
default) turns shadows off entirely and pulls the render distance in.

Multiplayer

Multiplayer uses the Grand-V relay - the same transport as the web version, so
you can share a room with browser players. You need a relay address
(ws://host:8012/relay), a room name and the access code from whoever is
hosting. Rooms hold two players and carry pose only: position, rotation and
model. Plain ws:// for now, no TLS.

Known limits

• ARM64 only, Vulkan required, Android 10+.
• First launch compiles the game and takes several minutes; early stutter is
  mostly loading from storage.
• Signed with a debug key. Fine for sideloading, not for any store.
• This patch covers the Wasmtime engine. The native wasm2c engine button still
  boots and logs but does not render; use the wasmtime engine for gameplay.

Tested

Galaxy A34 5G (8 GB) with the Wasmtime engine.

BytArch GTA-V for Android 0.1.4 (exports its own logs)

The launcher can now hand you the app's own log.

BytArch-GTA-V-android-0.1.4-debug.apk — arm64-v8a, Android 10+, debug signed.
SHA-256: dc5832261ac18be1c1f19e10d6030b2708c0d411ba6396701f85fda6ca8be15c

What's in 0.1.4

• Export logs in the launcher. The app writes its log to internal storage as it
  runs — engine output, errors, Rust panics — and this button saves a copy wherever
  you pick with the system file picker (Downloads, a USB stick, wherever).
• Everything from 0.1.3 still stands: the launcher crash is fixed, a picked
  /sdcard game folder is readable, and the graphics knobs and Grand-V relay are
  unchanged.

What the log covers

The log starts when the native library loads and records what the app itself
prints. It cannot catch a crash that kills the process outright (a native
SIGSEGV or the OOM killer) or anything before the launcher appears — for those,
adb logcat and tombstones are still the only source. If something goes wrong,
export the log straight away so its tail is close to the moment it happened.

Install

adb install -r over 0.1.3 — same signing key, so your settings carry over.

BytArch GTA-V for Android 0.1.3 (fixes a launch crash in 0.1.2)

0.1.2 is broken — do not use it. It crashes on launch. Use this one.

BytArch-GTA-V-android-0.1.3-debug.apk — arm64-v8a, Android 10+, debug signed.
SHA-256: 006ba54d0adfbe9ee1d12eea2b1c3c826ac03acbaa6430c88f11d5abead122fb

The crash in 0.1.2

The app died immediately on start, before the launcher appeared:

Caused by: java.lang.ArrayIndexOutOfBoundsException: length=24; index=24
    at dev.muguet.LauncherActivity.restoreGraphics(LauncherActivity.java:470)

Moving the frame limit into the graphics table made 25 settings, but two of the
three presets still carried 24 values. Adding the frame-limit knob had made
every preset row one entry short, and the launcher read past the end of the
array while restoring your saved settings. Only builds that already had a saved
frame-limit value were spared, which is why this slipped through CI — the unit
tests never touch the Java launcher.

What's in 0.1.3

• The crash is fixed. Both affected presets now carry one value per setting, and
  a preset that is ever short again falls back to the engine default instead of
  taking the app down.
• Everything from 0.1.1 still stands: game data from your own copy (folder in
  place, or ZIP), the full set of graphics knobs under Graphics, and
  multiplayer over the Grand-V relay.

Install

adb install -r over 0.1.1 or 0.1.2 — same signing key, so your settings carry
over. If you already installed the broken 0.1.2, upgrading to this one is enough;
no uninstall needed.

If the launcher says your game folder cannot be read, tap Grant file access
and allow "All files access": Android grants a folder but still refuses to open
files another app owns, which is what data copied over by a downloader or torrent
app looks like.

Still worth knowing

• Frame limit sits at the top of Graphics: Automatic / 24 / 30 / 42 / 60 fps.
  The values came from a community patch marked as untested — if the engine
  ignores them or misbehaves, choose Automatic.
• Low (phone default) is 30 fps at a 100 m draw distance with shadows off.
• The native wasm2c engine still does not render; use the wasmtime engine.
• Multiplayer is two-player pose replication over a relay someone else hosts,
  ws:// only, and it has not been tested against a live relay.