Free Riders Recompiled

繁體中文

Free Riders Recompiled is an unofficial port of the Xbox 360 version of Sonic Free Riders for Windows, Linux and Android, built through static recompilation. Play with a controller or keyboard, use Kinect / Kinect v2 or webcam motion controls on Windows, and bring your own VRM model to the in-game AVATAR rider. Kinect v2 support is experimental and still needs hardware validation.

The game's PowerPC code is translated to C++ with XenonRecomp and its Xenos shaders with XenosRecomp, then runs on a native runtime that stands in for the console's kernel, graphics, audio, input and Kinect.

This project does not include any game assets. You need your own legally acquired copy of the game (the USA/Europe disc) to play it: the launcher installs the game's data from your disc image. Prebuilt versions are on the Releases page; to build it yourself, see Building.

• Status
• Release notes
• System Requirements
• How to Install
• Settings
• How to Build
• Controls
• Kinect and Kinect v2
• Camera motion input
• VRM Avatar models
• Online play
• FAQ
• Repository Layout
• Credits
• License

What works today:

• Booting from the title screen through the menus into races: Free Race from start to results, and Grand Prix from its story scenes into the first race.
• Direct3D 12 and Vulkan rendering, with the shaders translated as the game meets them; sound; saving and loading records.
• Playing without Kinect: the Kinect is emulated. Buttons stand in for the voice commands the menus understand, and the pad drives the body a race reads (leaning, jumping, kick dash, grabbing, tricks).
• Physical Kinect and Kinect v2 input on Windows, with sensor skeletons passed to the game. Xbox 360 Kinect has been tested through races; Kinect v2 support is experimental. See setup and requirements.
• A launcher that installs the game from your disc image and keeps its settings, in English or Traditional Chinese, on every platform.
• Linux (Vulkan, SDL2), and Android (arm64-v8a) with on-screen touch controls and tilt steering.
• Optional webcam motion input for 1P on Windows, with estimated 3D body joints, controller handoff and a separate skeleton debug window.
• Experimental custom VRM Avatar models, selected in the launcher, with game-driven animation and hand-held items.
• File-replacement mods in HedgeModManager's format, managed in the launcher's Mods tab (Mods).

Known limits:

• Only the USA/Europe disc is supported.
• Much of the game has not been played through yet; stages and modes beyond those above may stop on something the runtime does not do yet.
• Linux and Android use shaders translated beforehand on Windows (shaders.pack, included in the releases). The game creates all of its shaders while it boots; releases include the matching shader pack.
• Android has been tried in the emulator, on Pocket S2 Pro (Adreno 750), and on AYN Thor (Adreno 740). The latest Android 10+ build completed a race on Thor at approximately 23–24 FPS with race time matching real time. Intro movies can still play slowly; this does not imply 60 FPS or the same performance on other devices. See Android performance.

Progress notes (mostly in Traditional Chinese) are in docs/, starting with docs/progress.md.

• v0.1.0 — First playable preview Released Windows, Linux and Android builds, with playable menus and races, save support, and controller/keyboard gameplay without Kinect. Included an English/Traditional Chinese launcher and Android touch controls and tilt steering.
• v0.1.1 — Early stability and rendering fixes Fixed a Grand Prix loading failure, removed accidentally enabled profiling overhead, and corrected rendering at non-native window sizes. Improved Android texture compatibility and surface recovery, and bundled a complete shader pack.
• v0.1.2 — Race results fix Fixed the game stopping at race results when it attempted to award an achievement. Achievement requests are now handled locally without Xbox Live.
• v0.1.3 — Customizable controls Added desktop settings for player input sources, controller selection and keyboard/gamepad bindings. Improved Vulkan compatibility with display surfaces that lack certain capabilities.
• v0.1.4 — Crouch and jump fixes Fixed controller input conflicts that could cancel crouch charging or jump release, including when holding the left stick down.
• v0.1.5 — Local two-player support Added independent player input routing and split-screen corrections. Fixed Gear selection getting stuck after Player 1 confirmed, reduced repetitive input logging, and removed unnecessary CPU queries.
• v0.2.0 — Webcam motion controls Added optional Windows webcam controls using estimated 3D body movement, a skeleton debug window, and automatic controller/camera handoff. Improved motion gestures and fixed single-player viewport stretching and exposure when 2P was disabled.
• v0.2.1 — Shader and Windows startup fixes Corrected the incompatible shader pack shipped with v0.2.0, which could cause a white screen or Vulkan device loss. Added shader-pack validation and bundled the D3D12 Agility runtime for affected Windows 10 systems.
• v0.3.0 — Custom VRM avatars Added experimental VRM 0.x/1.0 models for the in-game AVATAR rider, with game-driven animation, stance changes and held-item positioning. Models can be selected through the launcher.
• v0.4.0 — Real Kinect support Added physical Kinect input on Windows, sensor previews and Kinect v1 tilt controls. Improved player tracking, webcam handling and Windows graphics compatibility. Xbox 360 Kinect has been tested in races; Kinect v2 remains experimental.
• v0.4.1 — Rendering options and performance work Fixed shader reload failures during scene changes and controller-related rider pose distortion. Added independent internal rendering resolutions from 360p to 1440p and reduced CPU/rendering overhead.
• v0.4.2 — Settings and language selection Reorganized launcher settings, added game language selection, and fixed startup failures caused by unsupported system regions.
• v0.4.3 — Pipeline preparation and handheld improvements Added startup preparation and caching of known graphics pipelines to reduce compilation stalls during gameplay. Improved Windows timing, worker synchronization and CPU overhead, and introduced an optimized Android 10+ APK alongside the Android 9-compatible build.
• v0.4.4 — Android race timing and CPU improvements Improved Android CPU scheduling and guest execution overhead, corrected race simulation timing at lower frame rates, and fixed Vulkan shader compatibility on GPUs without 64-bit integer support. Racing was verified at approximately 23–24 FPS with time matching real seconds on AYN Thor; Intro movies remain slower than expected.
• v0.4.5 — Android Intro playback improvements Reduced ARM64 movie-decoding overhead with faster vector memory operations. On the tested AYN Thor, maximum sampled Intro video delay fell from several seconds to under one second, while race timing remained correct. Some playback delay may remain on other devices.
• v0.4.6 — Course stability and handheld improvements Fixed low-frame-rate traversal failures in Frozen Forest, Final Factory, Metropolis Speedway and Forgotten Tomb, plus loading and long-session stability issues. Improved controller steering and side reach, Android rotation recovery, race UI timing and texture handling. Added Android diagnostic ZIP export and further CPU/rendering optimizations; performance still varies by device.
• v0.4.7 — Windows CPU optimizations and rendering stability Reduced Windows guest checkpoint overhead and added D3D12 draw recording on a render thread. Fixed stale resolved textures when guest memory is reused and improved cleanup after rendering errors. Added isolated benchmark tooling and expanded rendering regression coverage. Vulkan retains synchronous recording by default; Android performance gains are not established by this release.
• v0.5.0 — Unleashed/Marathon-style architecture Moved the runtime to the Unleashed/Marathon Recompiled model: one render target per guest surface with deferred and depth resolves (race shadows now appear), direct guest memory access, a host o1heap for the title's heap and physical memory, every guest thread running in parallel with per-subsystem locks instead of a global lock, the render thread on every backend, and real-time race stepping on every platform. On the tested AYN Thor a race went from about 25 to about 49–50 FPS.
• v0.5.1 — Controller air tricks Fixed air tricks with a controller: turning the left stick in the air now raises a jump's rating, as turning the body does with Kinect. Also integrates a faster guest-memory path for the checked (debugging) build.
• v0.5.2 — Air trick landing fix Spinning the left stick for an air trick no longer leans or accelerates the board, which had carried trick jumps off the side of Rocky Ridge out of the course.
• v0.5.3 — Jump physics and Retry fix Desktop races step one original frame at a time again, so charged jumps off the side of Rocky Ridge land back on the course. Retrying a race from the pause menu no longer brings the confirmation back and leaves it stuck on screen.
• v0.5.4 — Grey flash fix Removed the single frames of flat grey that flashed now and then during races: a HUD sprite the game parks far off screen was sometimes drawn across the whole screen. Added diagnostics for stalls and single-colour frames.
• v0.5.5 — Mali GPU start-up fix Android phones and tablets with a Mali-G57 GPU (Helio G99, such as the Galaxy Tab A9) no longer crash at start-up: the renderer asked for one more descriptor set than these GPUs allow. The log now names each graphics start-up step.
• v0.5.6 — Air tricks on side jumps, touch pause menu Spinning the stick in the air raises a side jump's rating again. On touch screens the on-screen stick turns the pause menu's wheel.
• v0.6.0 — Mod support The game loads file-replacement mods in HedgeModManager's format, the one Unleashed and Marathon Recompiled use. The launcher's new Mods tab switches them on and off and sets their order.
• v0.6.1 — Two players and Relay Race on controllers Each player turns, confirms and backs out of the two-player menus with their own controller, and either can pause; a guest second player no longer adds a 10-second wait. Relay Race works with controllers: A swaps in the next racer. The launcher's settings can all be reached with a controller. 4-core CPUs keep the main thread's core to itself, and frames over 250 ms are logged.
• v0.6.2 — Fewer freezes, START skips story scenes The race and Relay hand-over freezes of up to a few seconds are gone: the main thread no longer spins on a lock other threads hold across system calls. START skips a World Grand Prix story scene, and the results screen's Kinect Guide no longer closes the game.
• v0.6.3 — Any install folder, voices apart from text, steadier sound The game starts from a folder with non-Latin letters on Windows, and full screen works with Vulkan on Linux. Voices can be English or Japanese apart from the text. Sound keeps a short cushion against crackles, and 4-core CPUs no longer pin the main thread. The programs have an icon, and HedgeModManager can find the game and manage its mods.
• v0.6.4 — No more getting stuck at start with Multi-core execution off With the launcher's Multi-core execution turned off the game got stuck at start on every device. The switch is gone: the game's threads always run in parallel, and an old setting that turned it off is ignored.
• v0.6.5 — Index buffers kept on the GPU (test build) Index buffers the game leaves unchanged stay on the GPU instead of being decoded and copied for every draw, and cached buffers are found without checking memory views each time. A test build for slower CPUs; SFR_INDEX_CACHE=0 turns the new cache off.
• v0.6.6 — Crash records in the Android diagnostic ZIP (test build) On Android 11 and later the diagnostic ZIP now says how the game last ended, with the system's crash record (tombstone) when it crashed in native code, so a crash that leaves nothing in the log can be located. Also has v0.6.5's index cache.
• v0.6.7 — Starts on Vulkan 1.1 phones Phones whose GPU driver offers Vulkan 1.1, such as the Snapdragon 8 Gen 1's Adreno 730 on some devices, crashed at the game's first frame; the crash record from v0.6.6 showed why. Includes v0.6.5's index buffers kept on the GPU and v0.6.6's crash records. Its fix did not take effect on those phones; see v0.6.8.
• v0.6.8 — Vulkan 1.1 phones, second fix v0.6.7 still crashed at the first frame on Vulkan 1.1 phones: its check could not see that the driver lacked the function. The function is now asked of the GPU driver itself, under the name that driver's Vulkan version uses.
• v0.6.9 — Faster races on Android On phones with one core faster than the rest, the game's main thread now gets that core: on an AYN Thor a race went from 45 to about 56 fps while racing, and to 60 at the start line.
• v0.6.10 — Less GPU work under Vulkan Vulkan shaders read their constants from uniform buffers instead of through buffer addresses, which phone GPUs can load once per draw: on an AYN Thor the GPU time per frame fell from about 14.8 to 10 ms. Frame rate there is unchanged (the game's CPU side now limits it), but the GPU has more headroom. Shader packs from earlier versions do not work with it.
• v0.6.11 — A race crash on 4-core PCs Part of each race frame runs on the game's job threads, and the game waited only 16 ms for them before going on. On slower 4-core PCs a job could still be reading the racer list when the game moved on, which crashed races (Issue #64). The game now waits for those jobs to finish; the race keeps its frame rate.
• v0.7.0 — Online play The game's Xbox LIVE mode works again, on this project's own server: one player's game hosts, the others join over the network, and players on Windows, Linux and Android race together (three devices tested; the lobby holds eight). See Online play.
• v0.7.1 — Avatars online, and a sign while a model loads An online race with a player using AVATAR closed the games of the others: a game without a custom model had its avatar system off and could not load another player's AVATAR. Online play now always starts the avatar system. A custom VRM model now loads in the background, with "LOADING AVATAR MODEL" and its progress shown in the corner, instead of the game appearing to freeze.
• v0.7.2 — 4K rendering and steadier Kinect v2 Render Size now offers 3840 x 2160 (4K, 300%) beside 360p to 1440p (Issue #94). A Kinect v2's joints are smoothed the way Kinect v1's SDK smooths its own, and the launcher's Kinect settings gain smoothing, lean sensitivity and crouch depth (Issue #97).
• v0.7.3 — Pause gestures, steadier menus, and more from knuckleslee Contributions by knuckleslee: pause a race with the Kinect's Pause Gesture or a Kinect v2's Stop Sign; a steadier menu cursor for motion input; the frame rate in the window title on Windows; adjustment windows when the game asks for the Kinect troubleshooter or Kinect Guide; and a choice of save folder in the launcher.
• v0.8.0 — Ultrawide displays Races fill displays wider than 16:9 (21:9, 32:9 and beyond) with a wider view and the HUD at the screen edges; menus stay centred over a full-width backdrop, and two-player screens keep the original 16:9 picture (knuckleslee's #112–#114). The launcher gains Display Mode (Borderless or Windowed), any window size, and Render Size as a scale of the output, starting at the original 720 lines. Both players holding LT hold hands in a Tag Race, BACK swaps racers in a Relay Race and X confirms dialogs, as in the No Kinect Patch (Issue #109). On a Kinect v2 a jump with both feet now jumps, and the display no longer turns off while playing (Issue #97).
• v0.8.1 — Full screen on Android The game always fills a phone's display: a phone that had run an older version kept the status and navigation bars over the game (Issue #118). Minimizing the game no longer closes it on D3D12.
• v0.8.2 — Two players on ultrawide displays Two-player races widen too on a display wider than 16:9: each half of a split race, a Tag Race holding hands and their On your Gear screen fill the frame, with each player's HUD at their own edge.
• v0.8.3 — Kinect jump diagnostics With a real Kinect, game.log records each crouch and jump the game detects and how high the hips went, so a jump that does not register can be diagnosed from the log (Issue #97).
• v0.9.0 — Races keep real time on slow devices Races keep the console's fixed step everywhere (side ramps no longer throw a racer off the course on a slow phone, Issue #123) and keep real time by not drawing some frames, which now also leave out most of the game's own drawing work. On ultrawide displays the race HUD is placed by which part of the game draws it, so text, the goal notices and the results stay together (Issues #131, #124). Also: a Kinect lean calibration fix (#132), a list of avatar models in the launcher (#132), a Linux hint when no file dialog is installed (#130), and guest memory on 16 KiB-page hosts.
• v0.9.1 — Map, Kinect calibration and dialogs The race map stays with its markers at a wide screen's edge (Issue #145). The launcher's Kinect preview can calibrate, setting the crouch depth from your own crouch (#97, #132). Linux file dialogs use the desktop's own portal (#130). On Windows the game's window keeps answering while the game is busy, and the launcher can show a webcam's picture.
• v0.9.2 — Big jumps on slow phones On a phone that can't keep 60 fps, a racer no longer falls short of Dolphin Resort's big jump: part of the game's work that frames left undrawn skipped is needed for the jump, and it now always runs.
• v0.10.0 — macOS and iOS First builds for Apple Silicon Macs (FreeRidersRecompiled.app, macOS 13.3 or later) and, untested, for iOS (an .ipa to sideload). On a Mac, races still run slowly. Also: on a slow phone the racer no longer falls out of Metropolis Speedway (Issue #154).
• v0.10.1 — Online check, smoother speed rail, older GPUs The launcher checks the online server before the game starts and says why it can't connect (Issue #161). A stall on Metropolis Speedway's speed rail is gone (#164). Vulkan GPUs without descriptor indexing get a fallback renderer (#134, untested on such hardware), and two rendering bugs are fixed.
• v0.10.2 — Newer Mali phones start Phones with a Mali-G715 or G720 GPU (Pixel 10a, POCO X7 Pro and others) crashed while preparing the graphics at start (Issues #166, #169). Their vertex shaders now go without the clip distance these GPUs don't support.
• v0.10.3 — Older Mali phones Vulkan 1.1 phones with an older Mali GPU (Mali-G72/G76, such as the Huawei P30 Pro in Issue #169) stopped before the game could start. The renderer now runs without the newer Vulkan features they lack; tested on a Mali-G72 test phone's graphics start-up, untested in a race there.
• v0.10.4 — Old Mali draws, Tensor speed, Kinect v2 trace Old Mali phones (Mali-G72/G76) no longer freeze on the first frame (#169). Phones with little CPU cores, such as the Pixel 10a, keep the game's helper threads off them (#176). Kinect v2: a Motion trace switch in the launcher and two jump fixes (#165). The fallback renderer for GPUs without descriptor indexing writes far fewer descriptors (#134).
• v0.10.5 — Touch-friendly launcher, first iPhone fixes The launcher scrolls with a finger and has wider scrollbars on touch screens (#186); the on-screen game controls come back with a touch even when a controller or keyboard is connected (#177). On iPhone the app has its icon, the launcher fits the screen, and a disc image in the app's Files folder is found without the picker (#185).
• v0.10.6 — Mac at full speed, iPhone starts On Apple Silicon Macs, races run at full speed: the GPU went from 6.5 to 60 fps on an M1. On iPhone the game no longer stops at its first frame (#185), and the launcher shows Chinese. On phones the game stays in landscape instead of turning with the phone (#177).
• v0.10.7 — Every race action on touch The on-screen controls gain the power-skill punches (LB/RB), a right stick to reach for Rings, and LT to hold hands in Tag races (#177), and now also draw on Windows touch screens. Android logs where race frame time goes, to find why some phones run slowly (#176).
• v0.10.8 — D3D12 on older drivers, very wide windows D3D12 no longer stops on drivers that can't flip the depth range, such as older NVIDIA drivers (#177). A very wide window draws as wide as the render size allows (up to about 11:1) instead of black bars from about 5.7:1 (#190).
• v0.10.9 — Fly board fix, frame skipping choice The Fly board at Dolphin Resort no longer sometimes launches a racer through the wall (#153). The launcher gains a Frame skipping choice for slow CPUs (#177). Phones with one much faster core, such as the Pixel 10a, run the game's main thread on it (#176).
• v0.10.10 — Test options, macOS with a Vulkan SDK installed The launcher gains a Test options page, so switches asked for in an issue are a choice instead of a command line. On macOS the game always uses its own MoltenVK, so an older Vulkan SDK on the Mac no longer stops it while preparing shaders (#207).
• v0.10.11 — Online server for the cloud, room passwords The online server comes as a Docker image to run on a cloud machine, so friends on different networks can race without anyone opening ports at home. A server can have a room password, entered in the launcher's Online play settings.
• v0.10.12 — Less work per frame The game's main thread does about 13% less work in a race frame on an Android handheld, so slower or hotter phones fall behind less often (#176).
• v0.10.13 — Touch the menus On a touchscreen the menu's hand cursor follows your finger, a tap on the title screen starts, and a new launcher setting skips the logo screens (#217).

• Windows: Windows 10 or 11 (x64), a CPU with AVX, a GPU with Direct3D 12 (or Vulkan 1.2).
• Linux: x86-64 with AVX and a Vulkan 1.2 driver (tested on Ubuntu 22.04).
• macOS: macOS 13.3 or later on Apple Silicon (tested on an M1 Mac mini). The Vulkan driver (MoltenVK) is inside the app. Experimental: menus run at full speed, but races are slow on an M1 for now.
• iOS: iOS 16.3 or later, sideloaded; a game controller is needed. Untested on a real device.
• Android: Android 9 or later, arm64-v8a, Vulkan 1.1; about 2 GB free for the installed game. Releases also offer an Android 10+ APK using native thread-local storage to reduce CPU overhead; prefer that build on Android 10 or later. Android performance remains experimental; the latest race timing and performance improvements were tested on AYN Thor and have not yet been re-tested on Pocket S2 Pro.
• Building needs the tools listed in docs/building.md.

1. Download the release for your system from Releases: the Windows zip, the Linux tarball, the macOS zip, the iOS .ipa or the Android APK. For Android 10+, choose android10-arm64.apk; the android-arm64.apk package retains Android 9 compatibility. Both use the same app identity and update existing installations without requiring an uninstall.
2. Unpack it into a folder of its own (on Android, install the APK; on iOS, sideload the .ipa with your own tool). On a Mac, open FreeRidersRecompiled.app with right-click › Open the first time: it is not notarised.
3. Start FreeRidersRecompiled and choose your disc image (.iso) when the launcher asks; it copies the game's data beside itself. Then press Start game. On iOS you can instead copy the .iso with the Files app to On My iPhone › Free Riders; the launcher finds it there.

The launcher groups settings by what you want to change:

Graphics starts with Display Mode: Borderless (default) fills the display, Windowed uses the window size chosen below it (the window size rows are shown only in Windowed mode). Render Size sits right below Graphics backend: Original (default) renders the game's own 720 lines, as every earlier version did, whatever the window or display. The other stops are a resolution scale of the output size (the display's in Borderless mode) from 0.25x to 3.0x in steps of 0.25x: 1.0x renders at exactly the window or desktop resolution, lower values reduce GPU load, higher values supersample. Changes to game settings apply on the next game launch.

The window size defaults to the desktop size until you choose another. The last entry of the window size list, Custom, shows width and height boxes for any size from 160 to 16384 pixels per side.

The window size list holds the resolutions the system reports for the display, plus common sizes and the desktop's; any other size is shown as Custom. The saved fullscreen key keeps its meaning (1 is Borderless, 0 is Windowed); a settings file without it now starts in Borderless.

The window size list also offers common ultrawide sizes (2560 x 720, 2560 x 1080, 3440 x 1440, 5120 x 1440). Two more options sit in the same group:

• Aspect Ratio (aspect_ratio): Auto (default on Windows and Linux) adapts the picture to the window or display; 16:9 (default on Android, where a wider picture costs a phone frame rate) keeps the original picture. Two-player races widen too: each half of a split race, a Tag Race holding hands and their On your Gear screen fill the frame, with each player's HUD at their own edge (SFR_TWO_PLAYER_WIDE=0 keeps them 16:9 with black at the sides). Both preserve the selected output resolution. With Auto and a window (or display, in full screen) wider than 16:9, the race's 3D view is widened (hor+), the race HUD stays in a centered 16:9 area, menu, title and calibration backdrops fill the whole width, and movies keep their 16:9 shape with black bars. 16:9 keeps the original behaviour untouched.
• UI Alignment Mode (ui_align): Edge (default) places the race HUD's side groups at the screen edges; Center keeps the HUD centered. The row is only shown with Auto; with 16:9 it is hidden, the original behaviour is untouched and the stored choice is preserved. Menu content stays centered.

The launcher sets SFR_ASPECT_MODE and SFR_UI_ALIGN, clears SFR_ASPECT_RATIO, and passes the selected window dimensions unchanged. Older aspect_mode=original settings load as 16:9. Changes apply on the next game launch.

In short, on Windows:

python scripts/bootstrap.py
./scripts/build_tools.ps1
python scripts/rom_tool.py extract --iso "your disc.iso" --output private/game --path default.xex
python scripts/prepare_recomp.py
./scripts/build_shader_translator.ps1
./scripts/build_tools.ps1 -Diagnostic
./out/build/host/FreeRidersRecompiled.exe

The launcher asks for your disc image on first run and installs the game beside itself. Linux and Android builds, and what each step does, are in docs/building.md.

Xbox and PlayStation controllers both work. On Android, translucent touch buttons cover the same actions when no controller is connected (punches on the screen's left and right edges, a small right stick for reaching), and tilting the phone steers in a race. Outside races a finger moves the Kinect hand cursor: touch anywhere away from the buttons and the cursor goes there (rest on an item to choose it, as with a hand); on the title screen a touch is START. On a PC the mouse moves the hand cursor the same way. Details: docs/race-controls.md, docs/pad-menus.md.

The Windows version supports physical Kinect v1 and Kinect v2 sensors for body tracking. Kinect is optional: controller and keyboard play do not require a sensor or its SDK.

Install the matching SDK, connect the sensor, then select Kinect in the launcher's Motion input > Camera setting and choose Open preview to check tracking. Both generations use the same option: the runtime tries v1 first, then v2. Keep your whole body visible and allow enough space to move.

Kinect v1 can supply skeleton, depth and color data. The current v2 backend supplies skeletons only, with additional skeleton-based steering and crouch/jump handling. Physical Kinect input is Windows-only; Linux and Android releases do not provide it.

SDK links, adapter requirements and troubleshooting: Kinect sensor guide (Traditional Chinese). For motion controls with an ordinary webcam, see the next section.

Gameplay and the skeleton delivered to the game, cropped from the same recording frame and arranged side by side. The debug window shows front and side views of the joints, without displaying the webcam image.

Windows releases include the models and runtime for webcam motion input. Select Motion input > Camera > Motion in the launcher and keep your whole body in view. Skeleton debug window opens front and side views of the joints the game receives; it does not show the camera image.

Camera input controls 1P. Using the controller takes priority; after 1.5 seconds without controller input, fresh camera tracking resumes. If tracking is lost, controller input remains available. Set 2P input to Off for single-player play.

Inference runs locally using ONNX Runtime 1.30.0 (MIT), with the OpenCV Zoo MediaPipe pose model and person detector (Apache 2.0). These models originate from Google's MediaPipe; this port uses their ONNX exports, without requiring the MediaPipe or OpenCV runtime. Model downloads are pinned by SHA-256 in scripts/fetch_pose_model.py. Licences and third-party notices are included in the Windows archive's licenses/ folder.

A webcam estimates relative 3D pose; it does not measure depth like Kinect. The Linux and Android prebuilt packages do not enable camera motion input. Setup, gestures, source builds and limitations: Camera input.

Starting with v0.3.0, you can use your own VRM 0.x / VRM 1.0 model for the in-game AVATAR rider. Camera motion input is optional; controllers and keyboard controls work with the model too.

A custom VRM model replacing the in-game AVATAR rider.

1. Open the launcher's Avatar models tab.
2. Choose Add model... and select a .vrm or binary .glb file. Desktop users can also type its path; Android imports a copy into the app's storage. Models you add stay in the list, so you can switch between them later.
3. Start the game and select AVATAR in the character menu, then choose your Gear. AVATAR must already be available in your game save; selecting a model does not unlock it.
4. To change models, return to the launcher, choose another one and restart the game. Don't use a custom model turns it off; Remove takes a model off the list.

One model setting is shared by both local players; it applies to whoever selects AVATAR, with separate poses for each player. Ordinary characters are unchanged. The model appears in Loading and races, follows the game's main body animation, jumps and stance changes, and supplies hand positions for held items. Models are read locally; no avatar model is bundled or uploaded.

This is experimental. A .glb without VRM humanoid bones stays static. Full MToon shading, transparent blending, spring bones, facial expressions and finger animation are not implemented. Some poses and item grips can look different between models, and complex models can reduce performance. Windows D3D12/Vulkan gameplay has been checked; full two-player VRM gameplay and physical Linux/Android VRM gameplay still need broader testing.

Troubleshooting and platform details: VRM Avatar guide.

Starting with v0.7.0, the game's Xbox LIVE mode works again, on a server this project provides instead of Microsoft's: Create Match, Quick Match, the lobby and online races. Windows, Linux and Android players can race together.

The same online race on a PC (the host), a ROG Xbox Ally X and an AYN Thor.

1. On every device: Launcher → General → Online play → Xbox LIVE.
2. One device hosts: turn on Host the server. The launcher shows the address the others enter ("Friends enter: 192.168.1.23"). The game runs the server itself on TCP and UDP port 47800, and only while it runs. The first time, Windows asks whether to let the game through its firewall: allow it (private networks), or nobody can connect. Android needs no setup.
3. The others connect: enter the host's address under Server address (for example 192.168.1.10), and give each player a different Online name. Your save and profile stay as they are. Test connection checks the server from the launcher, and Start game checks it again: if the server cannot be reached, the launcher says why (address not found, nothing listening, no answer) before the game starts. A game started before the host's keeps trying every 5 seconds, and its Xbox LIVE opens once it is in. The host may set a room Password; the others enter the same one (it is sent unencrypted, so don't reuse a real password).
4. In the game, open Main Menu → Xbox LIVE. The host chooses Create Match; the others choose Quick Match and press A on the lobby they find. The host starts the race.

Tested on a home network: three devices in one race, the host on a PC or on an AYN Thor, and a player leaving mid-race. Playing over the internet needs port 47800 forwarded to the host; that has not been tested. Leaderboards, Xbox LIVE Party, voice chat and achievements are not supported.

Playing with friends far away: instead of forwarding ports, run the server in the cloud (a VPS or a free cloud VM). Each release publishes it as a Docker image, ghcr.io/yuutatsubasa/free-riders-server; every player enters that machine's address, and only the server needs TCP and UDP port 47800. Every race packet goes through it, so pick a region near all the players. Steps: server/README.md.

Details and how it works: Online play.

How do I select Spanish or another game language? Open General > Game language in the launcher and choose English, Japanese, German, French, Spanish or Italian, then start the game. System language is the default. This is separate from the launcher's English/Traditional Chinese interface. Unsupported system languages use English; unavailable or unmapped system countries use the US profile and record a warning in game.log, without requiring changes to your OS settings. For direct runtime launches, set SFR_GAME_LANGUAGE to auto, en, ja, de, fr, es or it. Invalid values behave as auto.

How do I choose Vulkan or D3D12? On Windows, open Graphics > Graphics backend and choose either backend before starting the game. New settings default to Vulkan; existing saved choices are preserved. Linux and Android use Vulkan.

Can I change the game's internal resolution? Yes. Render Size is Original (720 lines, the default) or a resolution scale of the window (or display in Borderless mode) from 0.25x to 3.0x in steps of 0.25x; 1.0x matches the window/desktop resolution, so a 1920 x 1080 window renders 1920 x 1080. Apply it before starting the game. Lower values may help a limited GPU; higher values supersample at a greater cost (each side is capped at 8192 pixels). An older render_scale setting becomes the nearest step for the saved window. See Internal resolution.

How can I compare performance without changing game speed? Keep the normal 60 FPS cap and compare the same part of the same course, including slower-frame times. Uncapping currently speeds up the game logic too. Recording instructions and the limits of testing on a faster PC: Performance measurements. Guided 1P, 2P, Camera and VRM comparisons: Benchmark scenarios. Current local verification and hardware limits: Validation report.

Why is there a preparation screen before the game starts? Builds with a pipeline manifest prepare known graphics pipelines before the first game frame, reducing first-use compilation stalls. The first start may take longer; later starts reuse this device's cache. Keep the pipeline-cache folder. Close the window or press Escape to cancel (hold Back on Android). Unrecorded combinations can still compile during play. See Pipeline preparation.

Where are the settings and saves? Beside the launcher: settings.ini, save/ and game.log (on Android, in the app's files directory). The game plays as a local profile named "Player"; answer Yes when it asks "Are you Player?" and create save data when offered.

Why does the game need shaders.pack on Linux and Android? The Xbox shaders are translated with Windows tools while the game runs. The pack carries them, already translated, to machines without those tools; the game creates every shader it has while it boots, so a pack made with python scripts/pack_shaders.py after starting the game once on Windows (under Vulkan too, for the SPIR-V) is complete. Releases include one.

Can I use mods? File-replacement mods, yes, since v0.6.0: put each in its own folder in mods beside the launcher and switch it on in the Mods tab (Mods). Sound, texture and text mods made for the original game work once their files sit in a folder with a mod.ini; for example the Traditional Chinese mod. Code mods do not apply: the No Kinect Patch changes the original executable for Xenia, and the Kinect emulation here is the project's own code (see Credits).

Why does the release need my disc? The release holds the recompiled program, but none of the game's data (models, textures, sound, movies): that comes from your own disc image. The workflow in .github/workflows builds and tests only the parts that contain nothing from the game; releases are built from a disc on the maintainer's machine (docs/releasing.md).

Not in the repository, by design (see .gitignore): your disc image (__ROM__/), anything extracted from it (private/, game/), generated code and build outputs (out/, generated/), downloaded dependencies (tools/), saves and local reference checkouts.

• XenonRecomp and XenosRecomp: the PowerPC and shader recompilers.
• Unleashed Recompiled and Marathon Recompiled: the ports this project learned from (runtime layout, graphics, the launcher's shape). None of their art is used; the launcher's art and sounds are drawn and synthesized by its own code.
• Plume (rendering), SDL (Linux and Android), Dear ImGui (launcher), DirectX Shader Compiler (through dxc-bin), MoltenVK (Vulkan on macOS and iOS).
• Xenia: reference for the Xbox 360 kernel's behaviour and GPU texture formats/layouts.
• Xenia Canary's netplay build (netplay_canary_experimental, BSD licence): reference for the Xbox LIVE structures and message numbers online play answers. None of its code is used.
• ONNX Runtime (camera pose inference), OpenCV Zoo and MediaPipe (person detection and 3D pose models). Dependency versions and licences: THIRD_PARTY.md.
• No Kinect Patch by Rei-SanTH (tested by SmileyWorld, MagicShad and ivaschia): its reverse-engineering notes showed where the game reads the Kinect's voice commands and hand cursor, which guided the Kinect emulation here. The patch is licensed CC BY-NC-ND 4.0; none of its code or files are used or included.

• knuckleslee: code and research — D3D12 on Windows 10 (#14), the Avatar's body type (#15), playing with a real Kinect (#21), the benchmark workflow (#51), the pause gestures, steadier menus, window statistics, adjustment windows and save folder (#99–#104), ultrawide screens with an edge-anchored HUD (#113, #114), and detailed performance measurements on a 4-core PC that led to faster races (#33, #52, #62, #65).
• Saiyokage: long test sessions on Android, a check of every course's gear sections (#212), and the clips that led to the Fly board fix (#153).
• Players who reported problems, sent logs and crash dumps, and tested fixes: 18Spiderman15, Anim233, ArtisIan97, CODEX0827, Crappy-Productions, dareon88, Didgo1, Diego-Yoshi, francisc0frank0, Infeernuss, ITSeniy, Janybrito, Joka2010, JolTH-dot, KillerBunny12, KnivesDevilish, Koyurofox, Larry654, MegaCrashFan, Minuteworld94, mymes1, Mysterion2006, NeoCharmy, Saiyokage, shiny-ribbon, shireon12, tameradel578-cmyk.

Thank you all. Every report with a game.log or a dump made a fix possible.

This project was developed with the help of AI models: GPT-6, Claude Opus 5 and Claude Opus 5.5.

Licences and exact revisions: THIRD_PARTY.md, config/dependencies.lock.json.

Sonic Free Riders is © SEGA. This project is not affiliated with or endorsed by SEGA or Microsoft.

The project's code is licensed under the GNU General Public License v3.0 or later (COPYING). The game's own code and data remain SEGA's and are not covered by that grant.