Persona Dancing Recomp

PersonaDancingRecomp

The Persona Dancing games for PS Vita, running natively on PC. This is a fork of Project Nativ, which does the recompiling; this fork adds the packs and the renderer fixes these games need. Everything below the line is Project Nativ's own README.

Game	Title ID	Status
Persona 4: Dancing All Night (US)	PCSE00764	Playable: v0.9
Persona 3: Dancing in Moonlight (US)	PCSE01274	Playable, in testing
Persona 5: Dancing in Starlight (US)	PCSE01275	Playable, in testing

Persona 4: Dancing All Night is playable: the opening movie, menus and Free Dance, music in sync, the DLC songs and costumes, at 4x the Vita's resolution (up to 6x) and 30 or 60 fps. Story mode hasn't had a full playthrough yet: reports welcome.

• Sharper than the Vita: the close-up blur (the Vita draws those shots at quarter resolution and stretches them back) is turned off by default.
• Texture packs: packs made for Vita3K work unchanged (none are included).
• DLC: the add-ons you own, decrypted from your own dump.

What you need

Your own dumps, made from a Vita you own: the game, its update and any DLC (ux0:app, ux0:patch and ux0:addcont), and Sony's firmware update file. No game code, game data or firmware is in this repository, and none ever will be. Please don't open issues asking for them.

Setup for P4D, its options and notes are in packs/PCSE00764/README.md.

Persona 3: Dancing in Moonlight boots, plays its songs and DLC, and runs at the right speed at 60 fps in songs and menus (it's Atlus's own engine, as in Persona 5, where P4D's was Dingo's). Its pack is packs/PCSE01274; Vita3K texture packs work, such as the PS4 texture pack for P3D.

Persona 5: Dancing in Starlight is built from the same code as P3D and plays the same way, 60 fps included. Its pack is packs/PCSE01275.

Credits

Project Nativ by TheLostPantheon and its contributors: the recompiler, runtime and pipeline this all runs on. Atlus and Dingo made the games: support them by buying them.

---

Project Nativ

Project Nativ turns PS Vita games into native programs for macOS, Linux and Windows. You bring your own copy of a game. The tools recompile it on your machine, and it runs like any other program, with extras the Vita never had: higher resolutions, wider screens, 60 fps and mouse aiming, depending on the game.

How it works

A Vita game is ARM code written against Sony's system software. Nativ handles the two separately.

• The game's code is recompiled. A static recompiler translates the game's ARMv7 code, Thumb-2, VFP and NEON included, into C once, ahead of time. That C is compiled into a native program.
• The system underneath is rebuilt. Sony's own libraries that a game loads, such as libgxm, libc and FIOS, are recompiled with it from your firmware. Below them, a runtime stands in for the Vita's kernel and hardware: it runs the game's threads, draws its graphics on your GPU and plays its sound.

How it works goes into the design.

Nothing of the game ships

This repository holds no game code, game data or firmware, and nothing we distribute ever will. You supply your own copy of each game and Sony's firmware update file, and the tools decrypt and recompile them on your machine.

Supported games

Game	Release	Title ID	Versions
Killzone: Mercenary	US	PCSA00107	1.00, 1.12 (recommended: Botzone and online play)
Uncharted: Golden Abyss	US	PCSA00029	1.00
Unit 13	US	PCSA00014	1.00
Shovel Knight	US	PCSE00640	1.00
Persona 4: Dancing All Night	US	PCSE00764	1.00, 1.01

Each game's pack supports exact releases, recognised by the SHA-256 of the game's main program. Game-specific fixes, such as Killzone's physics fix or the widescreen cameras, patch code at fixed addresses, so they only fit the build they were written for. Your game data doesn't need to match; the main program does.

Not supported yet: other regions (EU, JP, Asia) and the later updates of Uncharted (1.03), Unit 13 (1.01) and Shovel Knight (1.08, Treasure Trove). The launcher recognises them and tells you which release it supports. It keeps an unsupported update, and the game runs without it. Porting a new release starts with dev/hookmap.py, which carried 43 of Killzone 1.12's 46 hooks over from 1.00 by matching code.

Getting started

Players use the launcher. It walks you through first-run setup, then builds and starts your games. Build it with launcher/build.sh; the result is launcher/nativ.

Developers can run each stage of the pipeline with ./vitarecomp from the top of the checkout. Run it without arguments for the full list.

On Windows, use the Python driver directly from PowerShell instead of the zsh wrapper:

.\.venv\Scripts\python.exe .\pipeline\vitarecomp.py --help

Replace --help with a stage and its arguments. The Windows player release includes its own Python and toolchain; the developer guide describes building that distribution on macOS or Linux.

The main stages, in order:

Command	What it does
firmware <PUP>	Decrypts Sony's firmware update file.
scan <folder>	Finds games, updates and firmware files in a folder, at any depth.
add <copy>	Adds a game or its update. import takes one that's already decrypted.
analyze <title>	Finds the game's functions.
recompile <title>	Translates them to C.
build <title>	Compiles the game.
run <title>	Plays it.
check <titles>	Runs the regression gate.

The pipeline's Python needs the packages in requirements.txt, installed in .venv at the top of the checkout. The Windows player release includes its Python in python/.

Your library

Your games, firmware, licences, builds and saves live in one library folder:

• dump/ inside a checkout, which git ignores;
• otherwise your per-user data folder: ~/Library/Application Support/ProjectNativ/Nativ/library on macOS, under ~/.local/share on Linux and under %LOCALAPPDATA% on Windows;
• or wherever ATIV_DUMP points.

Installing

./vitarecomp dist <folder> writes an install that holds only what ships. Running it again over an install it wrote updates the program and leaves your library alone. Two scripts add what a player's machine lacks:

• Linux: dev/linux-install.sh <folder> adds its own compiler and Python, for machines like the Steam Deck that have neither.
• macOS: dev/macos-install.sh <folder> adds SDL, SPIRV-Cross, FFmpeg's H.264 decoder and Python, and a Project Nativ.app to start it. The player needs only Apple's Command Line Tools, which the app offers to install. Build the libraries once with runtime/platform/macos/setup-toolchain.sh.

The player guide covers the rest from the player's side: first run, controls, online play and reporting a bug.

Repository layout

Folder	What's in it
launcher/	The launcher (hub.cpp): your library, first-run setup and settings. It runs the pipeline for you.
pipeline/	The vitarecomp driver, plus game and licence handling.
recompiler/	The static recompiler, its runtime header rt.h, and seeds for functions the analysis misses.
runtime/	What a recompiled game runs on: core/ (kernel and libraries), gfx/ (graphics), audio/, media/, input/, net/ (networking and online play), ui/ (window and in-game menu), platform/, debug/ and tests/. build.py builds it.
packs/<title>/	One folder per game: pack.toml (versions, modules, hooks and settings), hooks.c (that game's code patches) and shaders.txt (its shader recipes).
decrypt/	Decrypting firmware updates and game packages, converting SELF to ELF, and the table of Sony's function names.
servers/	Killzone's login server stand-in (kzserver/) and the relay node for online play (nativ-node/).
dev/	Developer tools: replays, diffs and bisects, the remote gate, tests and firmware research.
third_party/	Dear ImGui, stb, LibAtrac9, Monocypher and the HE-VAG tables, each with its licence.
docs/	The documentation listed below.
assets/brand/	The logo, wordmark and app icons, all drawn from one geometry by make.py.

Documentation

• Player guide: installing, first run, controls, online play, known issues and bug reports.
• How it works: the design, layer by layer.
• Working on Nativ: the pipeline, packs and versions, and working across machines.
• The runtime in detail: display timing, audio, the GPU backend, controls, hooks and metrics.
• Verification: the regression gate and how the translation and renderer are checked.
• Debugging a game: logs, captures, replays and the renderer's switches.
• Online play: matchmaking, finding other players, and the encrypted links between them.
• The shader compiler and the USSE instruction set: the Vita's GPU shaders and how we translate them.

Licence

Project Nativ is free software under the GNU General Public License, version 2 or (at your option) any later version: see LICENSE. Third-party code keeps its own licence, and THIRD_PARTY.md lists it with the projects parts of Nativ are ported from.

Nativ contains no Sony or game code. You supply your own games and the firmware from Sony's site; the games are recompiled on your machine and never leave it.

AI disclaimer

Nativ is made with the help of AI tools: much of its code and documentation was written with AI assistance, under its developer's direction, and tested on the games themselves.

Supporting Nativ

Nativ is free, and everything in it is for everyone. If you'd like to support its development, you can leave a tip on Ko-fi.