FH2 Recomp changelog

Stretch to the whole screen no longer distorts the image, and the car parts that flickered in the chase cameras are fixed. Upgrading from v0.4.4 keeps your settings.

New

• Fill the screen without distortion (Display > Image > Stretch to the whole screen). On phones wider than 16:9, the game now draws the world with the screen's own aspect instead of stretching the 16:9 image: cars, wheels and buildings keep their shape and you see more of the world at the sides.
• The HUD and minimap stay at 16:9 in the middle of the screen while driving, in free roam and in races.
• Menus, the map, popups, race intros and loading screens are 16:9 layers of the game: they are shown stretched to the whole screen, as before.
• Showing more of the world costs a little more GPU. If the frame rate drops, turn the option off to get the 16:9 image with black bars.

Fixed

• Wheels and trim of the car flickering in the chase cameras. The v0.4.4 change that flushed very small results (denormals) to zero in vector code also flushed them in the scalar math the car's parts are placed with, as the Xbox 360 CPU does not. That change is undone: vector code keeps its denormals again, as in v0.4.3.
• The same flicker coming back during a session. If anything turns denormal flushing back on in a game thread, it is now noticed and turned off again, and the log says where it was found.

Notes

• No new fh2_shaders.nfsp is needed: the v0.4.2 library works.
• Each session log now starts with the settings left in the app's own fh2.toml and the floating point mode the game runs with, to help with reports.

Frame generation arrives as a beta, cars no longer get thrown when they hit each other, and the usage overlay now shows power draw. Upgrading from v0.4.3 keeps your settings.

New

• Frame generation (beta) (Performance, under the FPS limit; off by default). It draws a frame between every two the game makes, so a game held at 30 FPS reaches the screen at 60. It works with both renderers.
• Best with the FPS limit at 30: the screen switches to at least twice the limit.
• The frame in the middle is built from the two images, like the frame generation some phones offer, helped by the game's own depth and camera matrices on the native renderer. The HUD and minimap are kept out of it, thin objects stay solid, and pixels with no good match show the real frame instead of a guess.
• It costs GPU time and shows each real frame about half a frame later.
• With it on, the overlay shows both rates, for example 30 fps -> 60.
• Power draw on the usage overlay: a second line under GPU/CPU/RAM shows the phone's power draw (battery current x voltage, 5 s average) and the frames per watt, also written to the session's usage log. While the phone is charging it shows PWR -- (charging), since the battery then can't tell the game's draw.

Fixed

• Cars thrown or jumping sideways after a car-on-car collision. A guard added in October against a crash at the festival props also changed the contact point of car hulls on every car-on-car hit, which threw the cars. It now only acts on the case that crashed.
• Sound mixing: 57 spots in the game's audio mixer packed half-precision values over their own source and read back bytes they had just written. They now pack from a copy.
• Vector math closer to the console (ARM64): very small results (denormals) are flushed to zero again in vector code, as the Xbox 360 CPU does.

Notes

• No new fh2_shaders.nfsp is needed: the v0.4.2 library works.
• Frame generation is off by default. If you see artifacts, turn it off and send the log.

A fix release: v0.4.2 ran the whole game on a single CPU core on phones with two big cores, and FPS dropped below v0.4.1 on them. This version gives the game its cores back. Upgrading from v0.4.2 keeps your settings.

Fixed

• Lower FPS in v0.4.2 on phones with two big CPU cores (two fast cores and six slow ones: Helio G85 to G99, Snapdragon 765G and other 7-series chips, Dimensity 700/810, Exynos 1280, among others). v0.4.2 started telling fast and slow cores apart by the kernel's core capacity. On these chips only the two big cores counted as fast: one went to the native renderer's thread, and every other thread of the game (game logic, audio, XMA) had to share the other one. In the logs of three users (OnePlus Nord, Galaxy A17, onn tablet), the CPU was only 12-16 % busy, the small cores sat idle, and the renderer waited ~50 ms per frame for the game, against under 1 ms in v0.4.0.
• Now the game is only kept on the fast cores when there are at least four of them. Otherwise it uses every core, as in v0.4.1, and the renderer's thread still gets the fastest core to itself.
• Fastest core for the game (Performance > Processor) gets the same fix: the other threads no longer share the renderer's core.
• On a Galaxy A17 with the fix, the CPU went back to 40-46 % busy and the renderer's wait dropped to ~15 ms per slow frame.
• Phones with four or more big cores (Moto G9 Play, Galaxy S23 Ultra) keep the same setup as in v0.4.2.

Notes

• If you turned off Pin threads to cores (Performance > Processor) to work around the v0.4.2 slowdown, you can turn it back on.
• Tip for weaker Mali GPUs (for example Mali-G57 MC2): FSR upscaling on the output can cost a lot. On a Galaxy A17 the GPU sat idle ~30 ms per frame with FSR on, and ~3 ms with scaling off. If your FPS is low with FSR, try scaling off or bilinear.
• No new fh2_shaders.nfsp is needed: the v0.4.2 library works.

A performance release: less work for the GPU and for the native renderer's CPU thread, smoother motion below 30 fps, HDR output on HDR phones, steering arrows for touch, and fixes for the striped cockpit camera and the faceted car paint on Adreno. Upgrading from v0.4.1 keeps your settings.

Faster

Measured on the Galaxy S23 Ultra (Adreno 740, GPU-bound) and the Moto G9 Play (Adreno 610), A/B in the same run and scene. Gains depend on the phone and the scene.

• Reflections updated in steps (on by default): the car reflection cube is redrawn a third at a time, the whole picture every 3 frames, instead of all six faces every frame. S23: +5 % FPS and +6 % FPS per GPU GHz; no visible difference in the reflections.
• Passes only where the game draws (on by default): FH2's bloom and blur passes draw one small quad each, but every pass loaded and stored the whole 1280x720 image. Passes now open over the area their draws use. PC: image area moved per frame 57 → 40 Mtexels, GPU busy 71 → 63 %.
• Reflection cube mips in one pass per level (on by default): 52 one-draw passes per frame drop to 4. User logs put those passes at 8-30 ms per frame on Mali. It also fixes dark chrome and black rims on lights and trim.
• Together with Smooth motion, these GPU changes gave +2 % FPS on the Moto and +6 % FPS per GPU GHz on the S23 against v0.4.1.
• Lighter native renderer CPU thread:
• Resolved textures are recycled instead of destroyed and recreated (~1,000 a second on the S23). S23: copies 8.1 → 1.4 ms per frame, ring thread 87-89 % → 55-56 % busy, GPU 93 → 98 % busy, FPS 43.4 → 46.1 (~+6 %). Moto: copies 3.0 → 1.6 ms per frame.
• No more fence polling before reusing resources: on the Moto (Turnip) each query slept waiting for the GPU. Copies 346 → 76 ms of every second, GPU 89 → 99 % busy, +3 % FPS.
• Only the renderer's own thread is pinned to a fast core (the Vulkan driver's threads had inherited its name and shared its core), and slow cores are found by the kernel's core capacity (the Snapdragon 662's Cortex-A53s were taken as fast). Moto: draw recording -21 % per draw, median FPS 16.4 → 17.1 (~+4 %).
• Game CPU: on ARM64 the ~57,000 floating-point mode toggles in the game code no longer write the CPU's FP control register (ported from Pinyon Shift, where those writes were most of Forza Horizon 1's physics time on the same chip as the S23).

New

• Smooth motion (on by default): every frame shown moves the game forward by exactly one step. Below 30 fps FH2 gave frames 0 or 2 steps, so motion juddered.
• HDR output (Display > HDR, off by default, HDR10 screens only): the scene's brightest lights (sun, headlights, reflections, taillights) go above white up to the screen's peak, while menus and the HUD stay at the chosen white. Options: White brightness, Highlights (off/low/medium/high, native renderer) and Brightness peak (Auto = the reported peak but at least 1000 nits, since many phones report less than they show). On Android 15+ the white follows Android's brightness slider and the highlights follow the screen's current headroom.
• Steering with two arrows (Others > Touch controls, or the in-game controls settings): two arrows instead of the left stick, as in other racing games. Holding one turns the wheel to the lock in 0.25 s, a tap is a small correction, and a ring shows how far the wheel is turned. Arrow steering strength from 40 to 100 %. The arrows can be moved, resized and hidden in the editor.

Fixed

• Native renderer, striped internal cameras on Adreno (cockpit, hood, bumper): with MSAA, bands of block noise changed every frame on the S23. Clean in 12 of 12 captures, 30 fps held at 2x and 4x.
• Native renderer, faceted car paint on Adreno: since v0.4.1 gave the reflection cube its mips, each triangle of the body could pick a different mip. Cube reflections now compute their level in the shader.

Notes

• Rebuild fh2_shaders.nfsp (tools/xenos/biblioteca.sh) to get the faceted paint fix; the old library still works.
• Present on its own thread (unstable) (Performance > Processor) is off by default: in our tests it gave no FPS gain and could make motion less smooth. Leave it off unless you are testing.
• The new performance options can be turned off in the launcher to compare.
• A touch layout saved before this version keeps its controls; the arrows start with the new defaults.

A fix-and-polish release: the Mali screen freeze is gone, the native renderer looks closer to the Xbox 360, new world detail sliders, keyboard and mouse support, and a lighter game CPU. Upgrading from v0.4.0 keeps your settings.

Fixed

• Image freezing on Mali GPUs (Poco X6 Pro / Mali-G615 and other Xiaomi phones): after ~20 s the picture froze (black or stuck on the loading screen) while the game and sound kept going. The presenter now renews its semaphores on every reconnection, catches presents Android silently drops, and if the reconnection loop does not end it moves presentation to the GPU's first queue for the rest of the session. Confirmed fixed on the reporting phones.
• Native renderer, car reflections: the paint reflected the sky and sun where the trees are and looked washed out; cube reflections now use the right direction, the reflection cube keeps its mip levels and samplers apply the game's mip bias.
• Native renderer, motion blur behind the car: the road under the car never blurred; it now does, as on the Xbox 360.
• Native renderer, anti-aliasing: MSAA now covers every pass of the scene (before, only passes the game cleared were multisampled, so 4x looked like off), and the launcher's FXAA option actually runs.
• Native renderer, foliage under MSAA: bushes no longer turn into scattered dots at 2x/4x; tree shadows are back from 1x shadow distance up.
• Scaling "Off" no longer forces 100 % render scale: it keeps your scale and shows it unfiltered (sharp pixels).
• Minimap pink / full map black with the new fast memcpy: copies that touch GPU memory go through the game's own routine.

New

• World detail sliders (Graphics): grass, objects, reflections, shadow distance and crowd, from 0.25x to 4x. Reflections, shadows, grass and crowd can also be turned off (grass and crowd off: native renderer only). Crowd off removes ~17 % of the scene's draws at the festival.
• Keyboard and mouse: detected on their own, like a gamepad — no setup. Racing layout with mouse camera; F4 in game rebinds every key. The touch pad hides while an external keyboard/mouse is in use and comes back on the first touch.
• Soft bush edges toggle (native, with MSAA): real alpha to coverage, softer but grainier on phones. Off by default.
• Lighter game CPU: guest registers kept as C++ locals instead of memory, ~316,000 calls between game functions made direct (no PLT), and the game's memcpy on the host's. On the Moto G9 Play, register save/restore helpers were ~5 % and memcpy ~4 % of the game threads before.
• Diagnostics: the swapchain reconnection loop is logged once with its cause instead of flooding the log; report log files grow to 5 MB.

Notes

• The world detail factors rewrite the game's TrackSettings.xml at start (in memory; your game files are not touched); works from a folder or an ISO, with either renderer.
• If you still get a frozen image on any phone, save a diagnostics report from the launcher and open an issue.

A stability and usability release: fewer crashes, freezes and broken screens, a new launcher, more options. Frame rate is about the same as v0.3.0 — the renderer does its work more cheaply, but both test phones are still limited by the same thing (see the tables).

Fixed (game)

• Paint shop crash fixed (the game's own setjmp/longjmp now reach the recompiled code).
• Garage stuck under the loading screen fixed (XamXStudioRequest now fails the way the console does).
• "Free" FPS limit could leave the 3D world black (black race on the Moto G9 Play): Free is now the same as 120 fps.
• My Cars photos, the dealer's car lights and several reflection/HUD images that came out wrong or empty: large one-off copies are read back to the game, sized by their destination, 16-bit targets clamped, scratch areas never read back with a different shape; 16_16 render targets accepted; visibility-query proxy draws no longer drawn.
• Sound stuttering or robotic on several phones: background audio decoding is now a toggle, off by default; audio keeps flowing when threads are pinned to cores; larger Android audio buffer.
• Achievement pop-ups now show Japanese, Korean, Chinese, Cyrillic and Polish text; achievement icons no longer appear in the phone's gallery.
• System bars (black bar at the top, gesture pill) hidden on phones that ignored the old method (HyperOS and others).
• "Could not find that ISO's path" (#1): ISOs picked through Downloads, media categories or other file managers work.

New

• New launcher: home screen with the game's own *Press Start* video, your player name (shown in game), a big Play button and a new look. Spanish added (English, Portuguese, Spanish).
• Native renderer is now the default and marked *recommended*. Phones whose GPU cannot run the emulated renderer (several Mali GPUs) are warned before playing instead of failing to start.
• Image options: MSAA 2x/4x on the native renderer, screen scaling Off / Bilinear / FSR 1.0 / CAS, FSR 1.0 presets (Mega quality 100 % … Ultra performance 33 %), extra sharpness slider.
• Phone vibration: the phone vibrates with the game's rumble (phone, gamepad or both).
• Renderer work per draw is cheaper: index cache and fetch cache across frames, identical constant blocks reused, vertex work no longer waits between passes, small render targets at exact size, reflection mips in one pass (optional). Ring cost per draw: −18 % on the S23 Ultra, −10 % on the Moto G9 Play (same scene).
• Diagnostics report: describe the problem before saving; the zip carries the last two sessions' logs, the exact build, a last-session summary (exit reason, min/avg/max fps, driver), device and storage state. Rooted phones: an extra report with crash files, kernel log and full logcat, and an optional one-shot performance profile.
• GPU usage on MediaTek phones in the overlay; logs keep repeated messages to 20 unless *Verbose log* is on.

Settings (launcher)

• Restore defaults at the foot of Graphics and Performance (asks first; the imported GPU driver stays).
• New defaults: native renderer, 100 % render resolution, anti-aliasing off, anisotropic filtering off, bilinear scaling, 30 fps limit; Performance: pin threads, vertex and index caches, vertices without waiting, small targets at exact size and ADPF on; fastest core and reflection mips in one pass off.
• The game's language follows the phone's until you pick one.
• File access is asked only when you pick the ISO, the game folder or a save — not when the app opens.
• Performance shows only the options of the chosen renderer; options the game does not apply yet are hidden; descriptions rewritten in plain words.
• Upgrading: settings you changed before are kept. Options you never touched take the new defaults — the renderer switches to native if you never picked one. Use *Restore defaults* to start clean.

Head-to-head (same parked scene, same camera change, uncapped)

S23 Ultra — render 100 %, anti-aliasing off, anisotropic off, shadows 100 %, Qualcomm 840 driver, GPU measuring on. GPU clock 680–719 MHz in both runs (no thermal cap; the v0.3.0 run was cooler).

Moto G9 Play — Turnip (Mr. Purple T30), shadows off, charging, same thermal state.

What the tables say: the frame rate barely moved because the ring (the thread that turns the game's GPU commands into Vulkan) is busy 94–100 % of the time on both phones, and resolve copies take ~35 % of it on the S23 and ~45 % on the Moto — those are the next target. On the Moto, resolution costs almost nothing: 33 % + FSR gives the same fps as 12 % with a much better image.

Caveats: one run per version and phone;

Much faster on both phones, same image.

• No read-backs of small resolves (on by default): the CPU used to read back 18–27 tiny 64×64 textures per frame for auto exposure, forcing the game, the ring and the GPU to take turns. 38 → 55 fps on the S23 Ultra.
• Vertex cache across frames (on by default): reuses the vertices the game hasn't changed instead of copying them again. Parked scene: 27 → 36.5 fps (+35 %); vegetation-heavy landscape: ~30 → ~40 fps; vertex uploads 12.5 → 1.0 GB per 10 s; 192 MB cache on phones with 8 GB+ of RAM.
• Exact-size small render targets (optional, off by default): the reflection cube's faces and reduction chain are created at their exact height instead of 720 rows. S23 Ultra parked: menores −0.9 ms, copias −0.4 ms per Swap. Moto G9 Play: steadier frame pacing (see below).
• Experimental Fastest core for the game toggle (off by default): gives the fastest core to the game's busiest thread instead of the ring. Measured −30 % in S23 Ultra testing (the ring still limits) — stays off.
• Performance hints (ADPF) always on; XMA audio decoding fixed on Android; pipeline cache saved after slow compiles; fewer clock reads on the ring; no GPU-timestamp overhead by default; render scale down to 12 %; watched fetch table restarts when full (fixes the 4 fps dip at the festival); usage log with clocks, battery and thermal headroom.

Head-to-head, S23 Ultra (same parked scene, render scale 100 %, cold, Anisotropic filtering 16x, FXAA):

Head-to-head, Moto G9 Play (race, 30 fps cap, render scale 78 %, native):

Caveats: vblank quantization at the 30 fps cap on the Moto, routes may differ slightly.

What's new

Play from the ISO

• The launcher reads your disc image (.iso) in place: no more extracting the game to the phone.

Native renderer (experimental)

• A second renderer that draws the game's GPU commands straight in Vulkan with pre-translated shaders. Much faster than the emulated one, with some image errors left.
• Fixed for FH2: grass and foliage, dust and small particles, the headlights at night (the night no longer looks like day), the sun's shadows.
• It needs the shader library fh2_shaders.nfsp, built on a PC from your own game files and copied next to the game. The README explains how.

Launcher

• New vertical menu, with each renderer's own options.
• Shadow quality slider for the native renderer (0 turns shadows off).
• FPS limit: 30, 60, 90, 120 or unlimited.
• Game language (every language on the disc) and app language (Portuguese / English).
• GPU drivers: import an adrenotools package (.zip), such as Turnip, with a Vulkan test before use.
• Compile shaders in the background (emulated renderer) and deferred scene copy (native renderer) are now options, off by default.

Achievements

• New Achievements page: every achievement of the game, unlocked ones in color with their date, locked ones in grey with a lock, secret ones hidden until unlocked. It appears after you open the game once.
• The in-game unlock notification is now small and centered at the bottom of the screen (it was huge and cut off on phones).

Fixes

• Native renderer texture memory: a fix in how unused memory is returned to the system.

Known issues

• The native renderer still has image errors in some places; the emulated renderer is the faithful one.
• Frame rate on phones is still below the console's in the emulated renderer.
• Some menu options are marked as "not applied yet".

Installing

Download FH2-Recompiled-0.2.0.apk below and install it. It updates 0.1.0 directly.

SHA-256: 3541e770817e43a9039063ba53b90e0cc4f977ad83c523eb316a665b4bfdd89a

The first public preview of FH2 Recompiled: Forza Horizon 2 (Xbox 360) statically recompiled to run natively on Android. The game code runs as native ARM64 code; the Xbox 360 GPU is still emulated on Vulkan, and that limits the frame rate today.

What works

• The game boots, runs its menus, cutscenes and races, with sound.
• Launcher with graphics and performance settings: render resolution in percent (12–100 %), anti-aliasing (off / MSAA / FXAA), anisotropic filtering, present mode (FIFO / MAILBOX), thread pinning.
• In-game overlay with frame rate and GPU, CPU and RAM use.
• Touch controls with a layout editor, and physical gamepads.

Performance

This is an early preview: expect a low frame rate. On a Snapdragon 8 Gen 2 phone races run at roughly 5–17 fps; on entry-level phones the game is playable only for testing. Recommended settings: render resolution 50 % or lower, anti-aliasing off, FIFO present mode, thread pinning on.

Requirements

• Android 8.0 or later, ARM64 processor, GPU with Vulkan 1.1 or later.
• 4 GB of RAM or more (6 GB or more recommended) and about 8 GB of free storage.
• Your own copy of Forza Horizon 2 for Xbox 360, USA edition (Title ID 4D530AA4), extracted from your own disc. Other editions have not been tested.

Installation

1. Install fh2-recompiled-0.1.0.apk (allow installing apps from unknown sources if Android asks).

2. Copy the extracted game files to Internal storage/jogos/ForzaHorizon2: default.xex, XMediaFacade_default.xex, SpeechFacade_default.xex and the media folder. You can also pick the folder from the launcher.

3. Open FH2 Recompiled, grant the file access it asks for, and tap Jogar (play).

The first launch takes longer while the shaders are prepared.

Known issues

• Low frame rate, limited by the Xbox 360 GPU emulation.
• The car sometimes passes through other cars, poles and some buildings, and can fall under the map.
• Some launcher options are not implemented yet; they are marked as such in the menu.
• The launcher is in Portuguese only for now.

Report problems in Issues with your phone model, GPU and Android version, and the diagnostics file from the launcher (*Salvar diagnóstico*).