Theft4 0.3.1 — Performance Improvements

Theft4 0.3.1 — Performance Improvements

iPhone and iPad · version 0.3.1 · build 142

A performance follow-up to the direct Metal release: less repeated CPU work,
cheaper first-use geometry, fewer allocations and better cache behavior. The
original Theft4 icon is back.

What changed

• Faster cold geometry conversion and reusable immutable upload backing.
• Less work per draw through cached shader metadata, pooled bindings and reusable
  frame bookkeeping.
• Warm pipeline recipes survive cache pressure instead of being cleared together.
• Upload VM allocation runs outside the cache mutex; retired sources are cleaned
  up incrementally and in-flight GPU resources retain their data.
• Less CPU busy polling and allocation in multi-object waits.
• Native attachment optimizations reduce proven redundant clear/load/store work
  while preserving the intended image.
• Improved compact iPhone launcher layouts.

Optional Mods menu

• Native Aspect Ratio: expand the viewport to the launch-window shape, with
  matching camera/lighting reconstruction, odd-size effects fixes and proportional
  pause-menu/radar corrections. More visible scenery can increase frame time.
• Custom Time Cycle: lighting/weather replacement for loose and packed installs.
  Credit and thanks to SBerrix for the custom time cycle.
• God Mode: player damage/death protection.
• Unlimited Ammo: reserve ammunition stays available while magazines deplete
  and reload normally.

Select mods before Play; changes take effect on a fresh game launch. The realistic
vehicle-handling mod remains planned work and is not included.

Older devices

GPUs without BC-texture support retain the one-time BC-to-ASTC preparation flow:
progress, ETA, pause/resume and a saved cache reused on later launches. The tested
A12Z uses it; the tested M5 supports BC directly and skips it. The check uses GPU
capability rather than an age cutoff. Updating in place retains existing caches.

Validation and current limits

33 native contracts, 9 mod contracts and 45 real-Metal graphics cases pass,
alongside CPU wait sanitizer checks and Release optimization verification.
The target remains under 30 ms of total frame work. Remaining first-use spikes,
heavy views and device-specific performance are still being improved; this is
not a universal locked-30-FPS guarantee. Host fixture savings are not whole-game
FPS percentages. Optional mod coverage still needs broader gameplay testing.

Full changelog
· 0.3.1 release details
· Technical changes and evidence

Install the IPA

1. Download Theft4-0.3.1-142-ios-arm64.ipa below. The Source code ZIP is not the IPA.
2. Install with a compatible sideloading tool such as AltStore or SideStore.
   The IPA is unsigned; your tool must sign it with your Apple account.
   Update the existing app in place to retain game files, saves and prepared
   textures. Do not delete the app first.
3. For a new install, launch once to create Files → On My iPhone/iPad → Theft4 →
   game, then close the app.
4. Prepare your legally obtained supported Xbox 360 USA retail game: title
   545407F2, media 6AC07221, base 0.0.0.5, matching TU8 patch to 0.0.8.5.
   A raw ISO or unopened update package is not a prepared installation.
5. Copy the prepared folder's contents into Theft4's existing game folder.
   default.xex and default.xexp must be at its root, not under game/game.
6. Reopen, Check Game Files, complete ASTC preparation if required, then Play.

Requires ARM64 iOS/iPadOS 26.0 or later. No retail game installation, title update,
save, prepared texture cache or developer provisioning profile is included.
The credited custom time-cycle resources are included. TestFlight is separate.

Complete installation instructions

Download integrity

IPA SHA-256: 2b80527f38a05ccf74a0a6c98e57cd5ac8d39f25b773c5499936ac63017b802b

Theft4 0.3 — Native Metal, Major Performance Rebuild & Older-Device Support

Theft4 0.3 — direct Metal and a rebuilt rendering path

Apple version 0.3.0, build 123, launcher label 0.3.
Source and the full engineering record are published on GitHub main. The
0.3 GitHub release
includes the unsigned ARM64 IPA and its checksum. TestFlight publication is separate.
The full engineering changelog is recorded here.

0.3 is the largest rendering change in Theft4 so far. The running game now sends
its prepared frames directly to Metal. This includes the actual city, characters,
lighting, effects and presentation, rather than just the separate Metal Lab.
The renderer and its CPU preparation, resource lifetimes and upload caches have
been substantially rebuilt around Apple's graphics API.

On the M5 iPad, the tester reports a huge improvement and very good gameplay at
the selected native resolution, with a remaining spike that now recovers.
Subsequent build 122 testing was also reported as excellent. The latest retrieved native log confirms a 2416×1359
internal/output target with no upscaling. This is much closer to the desired console experience. It does not establish a locked
30 FPS in every scene, uninterrupted long-session stability, or equivalent
performance on other hardware. The engineering target remains under 30 ms of
frame work, leaving margin inside the 33.3 ms interval for 30 FPS.

The direct Metal change

The previous production rendering route used the GTA IV frontend, Vulkan and
MoltenVK before reaching Metal. 0.3 introduces a live Metal worker, native render
passes, native resource bindings, completion-owned frame storage and direct
CAMetalLayer presentation. Normal Metal gameplay does not realize its draws
through the Vulkan provider or presenter.

Game shaders are prepared offline from the project's stock shader corpus. Their
constant banks and reflected texture/sampler fetches become explicit Metal
bindings. The game no longer needs to compile that corpus through a live Vulkan
translation path to produce its Metal draws. Pipeline variants and Metal driver
compilation can still require work when a new scene is encountered.

The game remains an ahead-of-time recompilation of the supported Xbox 360 release.
Its compiled ARM64 code still uses the compatibility runtime for the title's
memory, service and calling conventions. This release does not replace all game
logic with handwritten native code, rewrite physics or traffic, or turn the
project into a PC source port. Legacy Vulkan code and libraries remain in the
build for comparison and compatibility; direct rendering is a runtime route,
not a claim that the application has no Vulkan symbols or dependencies.

Rendering correctness and clarity

• Complete ordered frames now include the game's render passes, color resolves,
  depth handoffs, reflections and host effects. Draw order and required prior
  attachment contents are preserved across internal submissions.
• The port handles reversed viewport depth, the negative-one-to-one vertex depth
  convention, attachmentless draws, depth-only pipelines, per-instance stream 16,
  buffered/indexed rectangles and rotating output drawables.
• Packed lighting aliases and the title's float-pair multiple render targets
  retain their intended channel masks and storage roles. GPU-produced surfaces
  are distinct from immutable uploaded textures.
• Sampling preserves mip ranges, row/plane pitches, layers, cube faces and channel
  swizzles. Reflection updates wait for valid written content rather than making
  an entire otherwise valid scene fail.
• Blending, alpha discard, sample coverage, output scaling and clamping are checked
  against the game shader contract. Normal presentation uses GPU textures directly.
• Color targets use render-appropriate private storage without unnecessary usage
  flags that defeated compression eligibility in early Metal builds.

These changes restore the intended image through the new API. The tester reports
excellent visual quality and clarity; this is not a promise of new art assets,
rewritten lighting, HDR support, or a quantified image-quality advantage over
the original console.

Frame-time and memory work

• Draw preparation and encoding stream through the backend without building a
  second full vector of ready draws.
• Completed GPU frames recycle constant upload storage. Transient constants no
  longer compete with persistent geometry in the same upload cache.
• Vertex conversion is identified by the byte transformations actually required,
  so equivalent shader/layout combinations can reuse the same converted geometry.
  Whole-record offsets share conversion work while draw offsets stay exact.
• Converted vertex and index allocations are shared by the CPU conversion cache,
  draw packets and GPU upload. Full-buffer copies into a second CPU packet are
  eliminated, including when the original cache entry retires.
• Large immutable geometry participates in the bounded upload-view memo. Warm
  lookups avoid repeated resource-cache work while version, owner, size and range
  checks remain authoritative.
• Shader constants reuse immutable parent snapshots and projections. Only required
  changed ranges are materialized; constant vectors and draw storage are pooled.
• Registry updates are journaled. Pressure maintenance evicts incrementally rather
  than sorting entire caches every frame. In-flight GPU resources survive CPU
  retirement until their completion receipt releases them.
• Metal bindings skip redundant state changes, and depth/stencil variants reuse
  compatible render pipelines. Host utility pipelines have persistent archives.
• The final 0.3 geometry pass adds bounded index-range eviction instead of clearing
  all 8,192 entries, plus a fast repeat lookup and cheaper bucket hashing. Hot
  ranges survive saturation without weakening index, vertex or restart checks.
• A selected LOD routine is expressed as native C++ with tests for the original
  comparisons, missing resident meshes and unusual inputs. It preserves the
  title's streaming, fades and transition ownership.

The smaller CPU benchmarks are engineering evidence for individual paths. Their
percentages must not be added together or presented as a whole-game FPS gain.
Removing an API layer alone was not sufficient: early live Metal builds were
slower until their preparation, uploads, storage and lifetime behavior were fixed.

Graphics and everyday use

• Sharpening strength is independently adjustable, with bounded output and
  preserved alpha. It supplements the existing resolution and FSR 1 choices.
• AA Off is honored before the headless renderer starts. FXAA and SMAA remain
  choices; edge filtering has a performance cost. FSR 1 upscaling is not temporal
  antialiasing and does not replace every AA function.
• Native Pixels retains a centered 16:9 physical-pixel target, with no FSR for
  that selection. It does not render the game across the iPad's full non-16:9 panel.
• Frame Speed preserves the selected resolution, uses original shadows,
  earlier resident LOD and shorter world distance, and disables optional blur and
  edge filters. Optimized distance is 0.70× world distance with the title's
  existing LOD transitions; it is not a new occlusion or fading algorithm.
• Skip Intro Videos defaults On, skipping the opening credits and logos while
  retaining the game's normal loading and initialization.
• Ordinary play uses the optimized policy automatically, with no Retail Mode
  toggle. Development logging, probes and detailed GPU profiling stay off.
  FPS, CPU usage and frame-time graphs are independent options, off by default.
  Long Performance Capture is available before Play for a bounded five-minute
  timing report; it does not enable development probes. Capture resets Off each
  app launch. Required rendering validation and synchronization remain enabled.
• Game Mode is declared, and the tested development build retains the sustained
  execution request. These settings do not prove that the OS keeps Game Mode active
  or grants identical scheduling on every device or signing profile.
• Existing save export/import, automatic pre-import backup, controller/touch
  controls and launcher profiles are retained. These are carried-forward features,
  not all newly introduced in 0.3.

Devices without BC texture support

The compatibility path checks the GPU's BC-texture capability; it does not guess
from a device's age, name or an iPhone-generation cutoff. The tested M5 supports
BC textures directly. The tested A12Z requires prepared ASTC textures.

On a GPU that lacks BC support, a one-time preparation sweep converts supported
static BC1/BC2/BC3 textures to saved ASTC copies before gameplay. Setup explains
the storage/time requirement, shows progress and an estimate, and can pause and
resume. Later launches reuse the prepared cache. System provides cache deletion
with confirmation. Deleting it or changing the relevant source/cache identity can
require preparation again; dynamically created or uncatalogued textures can
still use the supported runtime conversion path.

This saves repeated gameplay conversion and avoids retaining large RGBA copies
as the default static-texture solution. It improves compatibility, not the A12Z's
underlying CPU/GPU capability. The newer-device BC route skips this requirement.
After transferring already-updated game files, Check Game Files verifies the
installation before requesting an update package it may not need.

Verification and remaining work

Build 123 passed 34 launcher/build tests and 27 CPU contracts. GPU validation
passed 45 graphics cases and 32 saved game draw replays in each of optimized and
diagnostic configurations, plus worker and delayed-GPU upload lifetime checks.
The sign...

Theft4 0.2.1 — Important Update

Theft4 0.2.1 — important iOS update

Version 0.2.1 (build 53) is an important update for iPhone and iPad. It keeps the official com.lukebrosious.theft4 app identity, so an in-place update preserves the existing app container, game installation, settings, caches, and saves. Do not delete the old app before updating.

The GitHub ios-arm64.ipa is unsigned and must be signed by the user's sideloading tool. The TestFlight build is separately signed by Apple. Neither artifact contains copyrighted game files, title updates, user saves, signing identities, or provisioning profiles.

Public sideload artifact: Theft4-0.2.1-53-ios-arm64.ipa
SHA-256: 3f278f0d3b07cfdda0e40a3672594d17bcd0499c01484d86b0a1845b7f571f9a

User-facing changes

• New After Hours launcher presentation and updated Theft4 app icon.
• Gameplay uses the proven centered 16:9 presentation on iPhone and iPad. The initial build 52 device-aspect experiment was withdrawn after testing exposed stretched world geometry, misaligned shadows, incomplete HUD correction, and increased frame-time instability. It will return only after the world, shadow, post-process and HUD projections are validated together.
• New Auto Optimize for This Device and Original Xbox 360 Settings buttons. Both are explicit, reversible starting points; manual changes still persist.
• Graphics choices include Native Pixels, 540p, 720p, 900p, and 1080p scene resolution, with FSR controlled independently where supported. Native Pixels uses the largest centered 16:9 physical-pixel target that fits the display.
• Expanded controls for shadows, draw distance, model detail, reflections, edge smoothing, anisotropic filtering, motion blur, and depth of field.
• New save export/import in System. Import validates the selected export and creates a dated backup of the current saves before replacement.
• Improved touch-control, frame-counter, frame-time graph, diagnostic status, and Files export behavior.
• iOS Game Mode metadata is declared for the official app.

Limited-memory device protection

iPhones and iPads with less than 7 GiB of usable memory are treated as limited-memory devices. This covers the 6 GB class and older/lower-memory models without changing the defaults on devices with 8 GB or more.

On a limited-memory device, settings that would create unnecessary rendering or memory pressure are constrained at launch and whenever graphics settings are changed:

• 1080p and Native requests are capped at 900p with FSR and fixed 1080p output;
• existing lower 540p and 720p selections remain lower rather than being raised;
• original shadow size, optimized draw distance, original model detail and reflections are used;
• additional edge smoothing, anisotropic filtering, motion blur, depth of field, and the optional FSR sharpening boost are disabled;
• launcher choices above the supported ceiling are visibly unavailable.

This is a pressure-control policy, not proof that resolution caused every reported failure. In particular, tester logs associated guest texture handle D8FFC2B0 with an image-creation failure on 6 GB iPhones, but the handle alone does not identify the allocation root cause. The cap is a safe mitigation while the new capture evidence is used to separate memory, pipeline, CPU, and GPU causes. Newer 8 GB-and-up devices keep their existing device-optimized choices.

Performance and renderer work

• Reduced producer/worker command-transfer copying, allocation, and lock hold time with batched transfer and bounded storage reuse.
• Avoided redundant resource-binding notifications and repeated vertex/index binding when validated state is unchanged.
• Reused immutable vertex-layout requirements and validated shader-constant parent snapshots; changed constant ranges are projected into fenced frame allocations instead of rematerializing whole blocks.
• Improved persistent-buffer reuse accounting, resource retirement, descriptor handling, pipeline diagnostics, resolve synchronization, and frame-slot ownership.
• Preserved native-renderer draw order and resource lifetime rules while adding stricter reporting for missing or invalid bindings.
• Added lightweight frame-stage/publication tracing and bounded analysis tools for pass chronology and frame pacing.

These changes target work that is redundant or diagnostically opaque. They do not constitute a claim of locked 30 FPS, lower temperature, or equivalent performance in every scene. Heavy city views and first-visit streaming still need matched-route device testing.

Lower-overhead, higher-value capture

The short detailed capture now collects 120 detailed samples across roughly 360 submitted frames instead of profiling every frame in a 600-frame window. GPU query boundaries are capped at 128 per sampled frame. Expensive image-memory and process-memory inventories are collected at capture start and periodically, not every sampled frame. Query reset work is limited to the active budget.

Each detailed capture also starts an aligned lightweight all-frame stage trace, then stops only the trace it started when the detailed capture completes. Background trace draining is throttled to about once per second. The combined export can correlate:

• GPU pass ranges, shaders, pipeline identities, query overflow, and queue time;
• CPU inclusive/self timing, worker wall/on-core time, command dwell, and guest production gaps;
• pipeline compile/wait/miss/create activity;
• uploads, descriptors, persistent-buffer hits/misses, fences, presentation, thermal state, effective output settings, and periodic resource inventory.

This design is intended to make under-33.3 ms investigations more concrete while reducing the profiler's own pressure. Profiling still adds overhead, so ordinary capture-off play remains the reference for perceived performance.

Save compatibility and installation

Update the existing official Theft4 app in place. The historical Lab app (com.theft4.m5lab) has a separate container and is not migrated automatically. Keep it until its data has been copied or backed up. Full sideload and game-data instructions are in IOS_SIDELOAD_INSTALL.md.

Verification scope

The release source includes host tests for device profiling and limited-memory resolution policy, constant projection/generation, publication tracing, native GPU attribution, native performance sampling, and resolve policy. The release build is produced with the official bundle ID and the repository's reproducible dependency patch set. Physical-device installation verifies packaging and signing; broad gameplay, visual-equivalence, thermal, and long-duration testing remain ongoing.

Theft4 0.2.0b

M5 Lab 0.1.3 (41) is now the foundation of the official Theft4 app. This 0.2.0b release adds first-launch game setup and System → Download Latest Log Capture to that Lab renderer and launcher.

Highlights: batched render-command delivery, reduced redundant state work, bounded pipeline preparation and frame resources, independent internal resolution and FSR controls, performance preset, FPS/frame-time display, and bounded 600-frame diagnostics. The capture can be exported after quitting and reopening the app.

Apple version: 0.2.0 (44). Bundle ID: com.lukebrosious.theft4. The historical com.theft4.m5lab app has a separate data container; copy or back up game files and saves before removing it. This IPA is unsigned for sideload tools to re-sign. No game data is included.

Measured Lab command-delivery improvements are detailed in the README. They are directional captures, not a claim of locked 30 FPS or measured heat reduction.

Full release notes: https://github.com/KoreanSeats1/Theft4/blob/v0.2.0b/docs/RELEASE_0.2.0B.md
Install instructions: https://github.com/KoreanSeats1/Theft4/blob/v0.2.0b/docs/IOS_SIDELOAD_INSTALL.md
IPA SHA-256: 9a80b818ead779e88258315d69e58380592c366f9a39d6175a779a4dbafbee70

Theft4 0.2.0

Theft4 0.2.0 — Lab renderer promotion

Theft4 Lab's renderer and gameplay performance work is now the regular Theft4
build. Direct device/sideload builds use the existing com.theft4.bringup
identifier. The existing TestFlight app uses com.lukebrosious.theft4.
Each 0.2.0 package updates its own prior app and container in place; they do
not migrate data between these two identities. The historical Lab app has its
own identifier and is not removed by either update.

Performance and frame-time work

• The guest producer and native render worker transfer commands in batches.
  Queue ownership remains ordered, while producer lock contention and worker
  batch-transfer time were reduced in measured M5 iPad captures.
• Common state commands use compact packets, and successfully queued identical
  bindings can be suppressed. Draws still capture and protect their resource
  generations. Bounded packet storage reuse reduces construction and release
  churn across dense scenes.
• Immutable vertex-layout requirements and unchanged vertex/index bindings
  are reused. Validated parent constant blocks receive only changed ranges
  when an exact fenced frame allocation is available.
• Texture content identity is separated from sampler settings. A19 devices
  walk the texture stages actually used by the shader in selected CPU paths.
  The existing full traversal remains available as a diagnostic fallback.
• Pipeline prewarming is bounded, with A19 prewarm disabled to avoid speculative
  backlog. A draw whose new pipeline is still compiling can be deferred rather
  than blocking the entire render worker; check visual correctness when moving
  into new areas.
• Two completion-owned native frame slots preserve overlap without releasing
  buffers or textures still in flight. The launcher now exposes 540p through
  1080p internal resolutions, FSR, graphics quality choices and a performance
  preset. A19 final output is capped at 1080p to reduce drawable pixel work.
• The frame-time graph shows publication intervals and recent spikes. The new
  System capture switch arms a bounded 600-frame detailed CPU/GPU profile;
  after relaunch, the download button saves a single diagnostic text bundle to
  Files and opens the share sheet.

The README explains each change and its
purpose. The engineering changelog and
Lab experiment records retain test conditions, reversions
and unresolved performance questions.

What has been measured

In separate instrumented 900p M5 iPad playthroughs, the build 32 to 33
command-transfer change reduced mean batch-transfer time from 4.53 to 0.16 ms
and producer queue-lock wait from 7.40 to 1.54 ms. Mean renderer interval
changed from 40.57 to 37.84 ms, p95 from 47.58 to 45.58 ms, and frames above
40 ms from 357/599 to 182/599. The routes and GPU work differed, so the
whole-frame difference is not a controlled proof of a fixed percentage FPS
uplift. See the capture review.

Heavy scenes and thermal state still matter. An A19 iPhone Air capture in
serious thermal state had a 44.5 ms median renderer interval; another run in
different conditions was 33.2 ms. Scene and output size differed, and the
captures do not measure CPU clocks or device power. Lower resolution and the
1080p output cap can reduce pixel workload, but lower heat and battery use
still require controlled device measurement. See the
A19 review.

For beta testers

Update Theft4 normally. Existing game files and saves are in the same app
container; do not uninstall the existing app. If a slow area occurs, note the
device model, route, graphics settings, approximate play time and whether the
device felt hot. For a detailed capture, enable System → Detailed performance
capture before starting the game. In the slow scene, double-tap the frame-time
graph, wait for 600 frames to complete, quit and relaunch, then tap
Download Latest Log Capture.
The result appears under Files → On My iPhone/iPad → Theft4 → Diagnostics.
Share that file with the report. Profiling itself adds overhead, so also
describe a normal run with capture off.

Known work still underway

Physics and guest scheduling in heavy scenes, sustained frame-time tails,
first-visit pipeline behavior, background/foreground recovery, controller and
touch coverage, and wider device compatibility remain active work. A 30 FPS
average or short smooth interval is not a locked 30 FPS result. This release
does not claim measured lower device temperature or universal stability.

Distribution

The GitHub ios-arm64.ipa asset is unsigned for users who sideload and re-sign
with their own account. Use the sideload guide.
TestFlight receives a separate Apple-signed build under its existing
com.lukebrosious.theft4 identifier and the same 0.2.0 version. The GitHub
source archive is not an IPA and contains
no game files, title update, saves or private signing material.

Theft4 0.1.3(a) — Shared iOS Optimizations

This update promotes the reusable, device-neutral parts of the A19 optimization work into the normal Theft4 app while keeping Theft4 Lab separate.

What changed

• Common render commands now avoid a separate allocation.
• Fixed-state hashing and validation are cheaper.
• The render worker performs less object movement.
• Repeated texture-binding preparation can be reused safely.
• Disabled diagnostics no longer perform expensive setup work.
• Production runs no longer auto-start detailed CPU/GPU profiling.
• A19-family iPhones disable speculative pipeline prewarm at launch to reduce render-worker backlog; authoritative pipeline creation remains enabled.
• The public executable uses general ARM64 scheduling instead of a single-chip compiler preset.

The launcher, game-file validation, 720p internal rendering, 1080p FSR1 quality output, motion blur, 4× texture filtering, audio path, two frame-resource slots, controller/touch input, and save locations are unchanged.

Theft4 Lab boundary

This release does not merge Lab's experimental pipeline deferral, draw-path changes, shader probes, unresolved GPU-lifetime work, or A19-only compiler scheduling.

Validation and expectations

The promoted data structures and memoization pass the focused host suite under AddressSanitizer and UndefinedBehaviorSanitizer. Treat 0.1.3(a) as an experimental public update, not a locked-30-FPS claim; matched A19 iPhone and M5 iPad gameplay/soak testing is still required.

Installation

1. Download Theft4-0.1.3a-6-ios-arm64.ipa.
2. Install it with AltStore, SideStore, or another compatible sideloading tool. The IPA is unsigned and must be re-signed with your Apple account.
3. Update in place if you need to preserve imported game files or saves.
4. Requires ARM64 iOS/iPadOS 26.0 or later. No retail game data is included.

IPA SHA-256: 2c67b0ab051c86cc2ed81d8dd13cb33137f2fa490f34eab02489014061476115

Full notes: docs/RELEASE_0.1.3A.md

Theft4 0.1.3 — M5 Stable iOS Release

Experimental ARM64 iOS/iPadOS release for sideloading. This is the device-tested M5 configuration; the isolated A19 and Theft4 Lab experiments are not included.

What’s fixed

• Restores the optimized native renderer build with explicit -O3 -DNDEBUG.
• Uses the native GTA IV renderer with two frames in flight and the existing M5 scheduling profile.
• Adds the 2 MiB native render-worker stack required to prevent the startup/black-screen failure.
• Keeps the existing 1280×720 internal render, 1920×1080 FSR1 quality output, and motion-blur defaults.
• Retains first-launch creation of Files → On My iPhone/iPad → Theft4 → game.
• Adds a build guard that rejects unoptimized AOT game, bridge, or native-renderer compiler commands before IPA packaging.

Install the sideloaded IPA

1. Install and launch once

1. Download Theft4-0.1.3-5-ios-arm64.ipa below. GitHub’s Source code ZIP is not the IPA.
2. Install it with AltStore, SideStore, or another compatible sideloading tool. The IPA is deliberately unsigned and the tool must re-sign it with your Apple account.
3. Open Theft4 once, then close it. First launch creates Files → Browse → On My iPhone/iPad → Theft4 → game and COPY GAME FILES HERE.txt.

Requires an ARM64 device running iOS/iPadOS 26.0 or later. Free Apple-account signing normally expires and must be refreshed on your sideloading tool’s schedule.

2. Use the exact supported game and title update

Supply your own legally obtained Xbox 360 files. This release validates:

• GTA IV title ID: 545407F2
• USA retail media ID: 6AC07221
• Base executable: version 0.0.0.5
• Title Update 8: delta 0.0.0.5 → 0.0.8.5
• Supported default.xexp SHA-256: 480aee5e2b42707791e7571bb8407c5bb3f6c7534f07f9beb426db4cfc648fd3

An ISO that works in an emulator is not necessarily the correct revision. Do not rename an incompatible update or bypass validation.

3. Prepare the game folder on a computer

The iOS app cannot use a raw ISO or unopened title-update package. It expects the output of Theft4’s validated staging process. The staging tool verifies the base/TU8 pair, extracts the update patch as default.xexp, preserves the base archives, extracts the required loose-file trees, and adds aes_key.bin plus .install-manifest.

The destination directory must not already exist:

theft4_stage /absolute/path/to/your-game.iso \
  /absolute/path/to/your-tu8-package \
  /absolute/path/to/NEW-staging-directory

Wait for Staging VERIFIED. The folder to transfer is then NEW-staging-directory/game. Developer build and simulator invocation details are in the iOS application build notes.

4. Confirm the prepared structure

At the top level, the prepared folder should resemble:

game/
├── default.xex          # USA retail base, version 0.0.0.5
├── default.xexp         # matching TU8 patch, target 0.0.8.5
├── aes_key.bin
├── .install-manifest
├── common.rpf
├── xbox360.rpf
├── audio.rpf
├── common/
├── xbox360/
├── audio/
└── update/              # present for a packaged STFS/SVOD title update

default.xex and default.xexp must be siblings directly inside game. Do not put default.xexp only inside update/. If staging used a raw validated default.xexp instead of an STFS/SVOD update package, no update/ directory is required.

5. Copy the contents to the device

Copy everything inside the prepared computer-side game folder into the game folder Theft4 already created:

• On-device: Files → Browse → On My iPhone/iPad → Theft4 → game
• From a Mac: Finder → your device → Files → Theft4 → game

The final device layout must be:

On My iPhone/iPad/
└── Theft4/
    ├── COPY GAME FILES HERE.txt
    └── game/
        ├── default.xex
        ├── default.xexp
        ├── aes_key.bin
        ├── .install-manifest
        ├── common.rpf
        ├── xbox360.rpf
        ├── audio.rpf
        ├── common/
        ├── xbox360/
        ├── audio/
        └── update/      # only when produced by staging

Do not copy the ISO, unopened TU package, outer staging directory, or another folder named game into the device’s existing game folder. A path such as Theft4/game/game/default.xex is wrong. Wait for the multi-gigabyte transfer to finish completely.

6. Verify and play

1. Reopen Theft4.
2. Open System and choose Verify Game Files.
3. Resolve any reported base or title-update mismatch.
4. Return to Play and start the game.

A physical controller works whether touch controls are enabled or disabled.

Updating an existing sideload

Install the newer IPA in place with the same bundle identity to preserve the app container. Deleting Theft4 first also deletes its app-local game files, settings, caches, and saves. Keep separate backups before reinstalling or changing sideloading tools.

Common mistakes

• default.xex missing: the folder was nested as game/game; move the inner folder’s contents up one level.
• default.xexp missing: the unopened TU package was copied instead of staged.
• TU8 mismatch: the update is for another region or base revision; use the exact 0.0.0.5 → 0.0.8.5 patch above.
• Game not detected: confirm the copy finished and used On My iPhone/iPad, not iCloud Drive.

No copyrighted game files, title update, saves, Apple signing identity, or provisioning profile are included.

Download integrity

IPA SHA-256: 1c8db01bc735bf7badd62a8fb113a51c438d95deb792e134338626075de06f2c