RyGT: Gran Turismo Sport (CUSA03220, update 1.69) as a native Windows program
Build of 2026-10-17 - github.com/mlgprorektm8/RyGT

Quick start
  1. Unzip this folder on the SAME DRIVE as your game dump (the game's files are linked into it,
     not copied; on another drive Windows Developer Mode must be on).
  2. Run RyGT.exe and pick:
       Game (CUSA03220)          your decrypted base game folder (the one with gt00.vol)
       Update 1.69               your decrypted 1.69 update folder (leave empty if it is already
                                 merged into the game folder)
       System modules            a folder with your PS4 firmware's decrypted modules
                                 (libSceFont, libSceFontFt, libSceFreeTypeOt, libSceJson2,
                                 libSceNgs2, and libSceJpegDec and libScePngEnc if you
                                 have them; .sprx or .prx, searched in subfolders too)
       Fonts                     a folder with your PS4 firmware's font and font2 folders
  3. Press Set up. It converts the game for Windows (a minute or two), gives GTSport.exe the ryGT
     icon, links the game files into app0, copies the fonts, makes the offline livery scripts
     from your game files (see tools\adcpatch) and prepares the shader list (step 7 below). Its log is in setup.log.
  4. Press Play. Logs are written to stdout.log and stderr.log. After Set up you can also open
     GTSport.exe directly; it starts the same way.

Options (RyGT.exe)
  Splash screen, FPS counter and Discord Rich Presence can be turned on or off. Sparks, tire smoke
  and the game's other particle effects are always on.
  Start in fullscreen      Borderless fullscreen on the display the window opens on.
  System memory (RAM)      16 GB (minimum) or 32 GB+ (recommended); picked from your PC the first
                           time. With 16 GB the driver's shader-cache file is off and fewer GPU
                           images are kept for reuse: about 9 GB used in a heavy race instead of
                           11-13.5 GB. With 16 GB, keep Windows' page file on automatic.
  Upscale with AMD FSR     The game draws at 1920x1080. With a bigger window or screen, FSR
                           scales it up sharper than plain stretching. It uses AMD FSR 3.1.4,
                           the newest FSR for Vulkan (FSR 4 is DirectX 12 only), through
                           amd_fidelityfx_vk.dll. Untick "Use FSR 3.1.4" for FSR 1.
                           "FSR sharpening (RCAS)" adds sharpening on top.
  Upscale with NVIDIA DLSS Needs the optional DLSS plugin, which is not in this package (NVIDIA's
                           SDK can't be shipped with the GPL renderer). Build and install it from
                           github.com/mlgprorektm8/RyGT/tree/development/plugins/dlss; the box
                           stays grey until dlss\ryGT_dlss.dll and dlss\nvngx_dlss.dll exist.

  Frame generation         AMD FSR 3.1 frame generation shows a generated frame between each pair
                           of game frames: about twice the frames on screen (the FPS counter shows
                           "N FPS (M shown)"). Works on any GPU, with or without upscaling. The
                           game gives no motion vectors, so fast edges and the HUD can ghost. It
                           switches on once the splash screen is gone.
  Precompile shaders       While the splash screen shows, every shader the game has used before
                           on this PC is built, with a progress bar; the game waits until it is
                           done. The first time after many new shaders this can take minutes;
                           after that, seconds.
  When new shaders compile What happens when the game needs a shader it has never used, with
                           "Compiling new shaders..." in the bottom left:
                             Slow motion (default)  the game runs at a quarter speed until it is
                                                    compiled; the objects that need it appear then
                             Pause the game         the game (its clock too) stops until it is
                                                    compiled
                             Keep going             full speed; those objects pop in when ready
                           In races the game never pauses or slows down for shaders: objects
                           whose shaders are still compiling pop in when ready.
                           Compiled shaders are kept and reused next time.
  Compile batching         With "Pause the game": Off, Short, Medium or Long lets one pause also
                           compile the shaders the next moments need (up to 0.1, 0.3 or 1 s):
                           fewer, longer pauses.
  Wet-road reflections     In the rain the game draws the whole scene a second time for the wet
                           track's reflection. Untick it for much more speed in rain (about +30%
                           in the Tokyo rain benchmark); the road then looks less glossy.
  Rear-view mirror at half rate
                           The mirror is redrawn every second frame (a little faster).
  Background picture       launcher\background.png is the picture behind the launcher. Replace
                           it with any PNG of the same name (16:9 looks best), or delete it for a
                           plain dark launcher (see launcher\README.txt).

What is in this package
  RyGT.exe              The loader above.
  launcher\             The launcher's background picture (made for RyGT; replace it freely).
  tools\stackdump.exe   Saves what every thread is doing to user\log if the game gets stuck.
  tools\adcpatch\       Makes the offline livery and decal scripts from your own game files at
                        Set up (Nenkai's GTToolsSharp and GTAdhocToolchain, MIT; see its README).
  libs\                 RyGT's runtime libraries (github.com/mlgprorektm8/RyGT), shadGT's renderer
                        (libSceVideoOut.prx) and its audio, NP and other HLE libraries
                        (github.com/mlgprorektm8/shadGT, branch ryty-gpu), and generated logging
                        stubs for functions neither implements.
  converter\ryty.exe    The converter that turns the game into GTSport.exe.
  user\custom_configs\CUSA03220.json   Renderer settings for GT Sport (readbacks: relaxed).
  amd_fidelityfx_vk.dll AMD's signed FidelityFX library (SDK 1.1.4, FSR 3.1.4; MIT license in
                        amd_fidelityfx_vk-LICENSE.txt).
  other *.dll           MinGW runtime the libraries and converter use.

What is NOT included, and why
  No game files, no converted GTSport.exe, no PS4 system modules or fonts. Those are Sony's and
  Polyphony Digital's copyrighted files. You need your own decrypted dump of GT Sport CUSA03220
  with update 1.69, and the system modules and fonts from your own PS4 firmware.

What Set up does (if you want to do it by hand)
  1. Unwraps the 1.69 eboot.bin and the modules below from SELF to ELF (their segments are not
     encrypted) and rewrites their PT_SCE_RELRO segment as a read-write PT_LOAD.
  2. Puts them in convert\sce_module next to convert\eboot.elf:
       from the game:      libc.prx, libSceFios2.prx (sce_module), libSceSecure.prx and
                           logiWheel.prx (the game's root)
       from your firmware: libSceFont, libSceFontFt, libSceFreeTypeOt, libSceJson2, libSceNgs2,
                           libSceJpegDec and libScePngEnc
  3. Converts:
       converter\ryty.exe --windows --ps4 --skip-syscall-check --registry --report port-report.json convert\eboot.elf GTSport.exe
     This writes GTSport.exe and app0\sce_module\*.guest.prx.
  4. Fills app0 with the game's files (the update's over the base game's, except eboot.bin and
     sce_module) as hard links, and links sce_sys as a folder junction.
  5. Copies the fonts to sys\common\font and sys\common\font2.
  6. Makes the offline livery scripts:
       tools\adcpatch\adcpatch.exe all "<game folder>" "<update folder or empty>" patches\scripts
  7. Prepares the shader list (tools\adcpatch\shaders.pack): which of the game's shaders exist
     and where, read from your game files, so they can be built before the game needs them. No
     game code goes in it.

Status
  Boots, menus, races and the race summary work. Races run at about 42-60 fps depending on how
  many cars are on screen (Intel i7-13700KF, NVIDIA GPU). The first 30 seconds of a race can
  stutter while pipelines compile. A few draws in the race summary can occasionally read garbage
  vertex descriptors and are skipped.

  New in this build:
  - The one-frame white flash after picking a car is gone, and so are the car screens'
    blown-out car and white or magenta dashboard panel every few seconds.
  - The frosted-glass bars (the top bar, the car list) no longer flicker dark.
  - Races no longer stop for seconds to compile shaders: no slow motion in races, and objects
    whose shaders are still compiling pop in when ready.
  - Set up prepares a shader list from your game files (step 7 below); folders set up with an
    older RyGT.exe get it the next time Play is pressed.
  Hotfix in the 2026-10-16 (fourth) build: the garage no longer keeps loading after a livery is applied (it waited for GT Sport's
  server to check the livery), and saved liveries get ids from the clock so a later one can't
  overwrite an earlier one. To update a folder, unzip this over it and press Play in RyGT.exe
  once: it makes the scripts again because tools\adcpatch is newer.
  New in the 2026-10-16 (fourth) build: the livery editor works offline. Liveries can be applied to cars, and your
  own decals (.svg files in a decals folder next to RyGT.exe) show in the editor. Set up makes the scripts
  this needs from your own game files; folders set up with an older RyGT.exe get them the next
  time Play is pressed. The Lewis Hamilton Challenge is unlocked too.
  New in the 2026-10-16 (third) build: the new renderer is the only renderer (about a third faster in heavy
  races). While it builds its own shaders, draws use the shaders the old renderer already
  compiled on this PC, so switching to it no longer pauses or stutters. The graphics presets are
  replaced by a System memory (RAM) setting.
  Known issues: a car's interior can flicker on the loading screen before a race, and the Scapes
  home menu backgrounds can show black.
  New in the 2026-10-16 (second) build: a fix for freezes with frame generation on while many new
  shaders compile (frame generation now pauses meanwhile), the new renderer's helper thread
  (a little faster), and quality presets (Low uses about a third less memory).
  New in the 2026-10-16 build: the new renderer (option "New renderer", see Options; about a third faster
  in heavy races), freed render targets are reused instead of rebuilt (all modes), and options
  for wet-road reflections and a half-rate rear-view mirror.
  New in the 2026-10-15 build: renderer speed-ups (a few fps in heavy races such as Tokyo Expressway with
  20 cars in the rain) and faster shader matching on the command thread.
  New in the 2026-10-14 (second) build: text fields (like a livery's design name) open an on-screen keyboard, and
  errors the game handles itself no longer crash it (every C++ exception the game threw used to
  end the game, which may also explain some random crashes).
  New in the 2026-10-14 build: tire smoke shows too.
  New in the eighth build: sparks, tire smoke and the other particle effects show (an option in
  RyGT.exe, about 8 fps in races).
  New in the seventh build: Scapes thumbnails and backgrounds render (the firmware's JPEG decoder is
  used; press Set up again in an existing folder to get it).
  New in the sixth build: GTSport.exe can be opened directly (no launcher or script needed, no console
  window); the Skip this launcher option and Play-GTSport.cmd are gone.
  New in the fifth build: the Start in fullscreen option, and GTSport.exe gets
  the ryGT icon (folders set up with an older RyGT.exe get it the next time Play is pressed).
  New in the fourth build: AMD FSR 3.1.4 upscaling (FSR 1 is still an option).
  New in the third build: the FSR upscaling options and support for the optional DLSS plugin.

  Fixed in the second build: the crash on a fresh save at boot, striped photos in Brand Central and
  black Scapes/dynamic scenes in the showroom, the crash when buying a car, and a crash at one
  showroom dynamic scene. Launch takes about 2 seconds longer (the renderer protects the game code
  from Windows exception frames before the game starts).

  Known issues: the screen stays white for about 6 seconds before the home menu (black on a PS4),
  and one showroom dynamic scene renders black.

License
  RyGT (Ryty) and shadGT are GPL-2.0. Their source, with every change in this build, is at
  github.com/mlgprorektm8/RyGT and github.com/mlgprorektm8/shadGT (branch ryty-gpu).
