Tekken Tag 2 Ultimate Edition

Tekken Tag 2 Ultimate Edition

An unofficial native Linux port of Tekken Tag Tournament 2 Wii U Edition, made by static recompilation: the game's PowerPC code is translated to C++ ahead of time and runs as native x86-64 code on a reimplementation of the Wii U's system libraries. There is no CPU emulation; the game's GPU commands and shaders are translated to Vulkan as it runs.

Features

• Plays natively: intro, menus, character select, arcade mode and versus matches, with sound and saves. Arcade mode has been played through by hand.
• 120 frames per second on displays of 100 Hz and more: between each two frames the game renders, the port shows one more, drawn from the same frame with the camera, objects and character skeletons blended halfway. The game's logic, physics and hitboxes stay at 60 Hz. When other programs keep the GPU busy, frames go out without their extra frame rather than slowing the game down. The launcher's Settings can turn it off.
• Higher resolutions: up to 4x the original 720p; by default the smallest scale that covers your main display (2x, 2560x1440, on 1080p and 1440p displays; 3x on 4K), or the one chosen in the launcher's Settings (1280x720, 1920x1080, 2560x1440, 3840x2160 or 5120x2880).
• Even frame pacing on 120 Hz and 240 Hz displays (with VK_KHR_present_wait2): the game's clock follows the display's refreshes, so every image stays on screen equally long.
• Controls and icons as on a computer: menus confirm with the bottom face button and go back with the right one, as on the other consoles (Nintendo controllers keep the Wii U's way). Button icons follow the controller in use: PlayStation controllers get PlayStation-style icons, any other neutral ones that show each face button by its place on the pad. The game's texts show the icons where they named the Wii U's buttons, and the title screen's logo says "Ultimate Edition" where it said "Wii U Edition", in the same brush lettering. All of it is made by the port from the Wii U game's own files.
• Local multiplayer: in VS Battle, Team Battle and Pair Play every keyboard or gamepad that presses Start joins as a player of its own, up to five, and the player entry screen pictures the keyboard, PlayStation, Xbox-style or Nintendo controller each player holds, drawn in the game's style. Everywhere else every device plays as the one player.
• Solo Ghost Battle: a new Offline mode, below GHOST BATTLE: Ghost Battle fought one on one. The player picks one fighter (no Tag or Solo choice) and every ghost fights alone, with its own name, rank, record and recorded play; wins, ranks and rewards count as Ghost Battle's.
• Position reset in Practice, as in Tekken 8: 3 and − (Select) pressed together put both fighters back where the stage put them; a hint at the bottom right of the screen says so, in the look of the game's own.
• Frame data in Practice, as in Tekken 8: a panel for each player at the bottom of the screen shows the damage of their hits and combos, the hit level, startup and active frames of their last attack, frame advantage after a hit or block, counter hits, punishes and wall hits, posture and distance. The pause menu's ULTIMATE SETTINGS submenu (in place of TOUCH SELECT) sets them up, and can colour the fighters by frame advantage after a hit or block (blue ahead, red behind).
• Hitboxes and a view from above in Practice: the fighters' bodies as the game tests hits against them, in 3D, and their attacks' hit lines, with the parts an attack reaches lit red; a window shows the fight from above as well, to see what a sidestep avoids; slow motion at half or a quarter speed.
• Input history in Practice, as in Tekken 8: COMMAND HISTORY (on from the start of each Practice session) shows the player's inputs in a column on the left, newest on top, each with the frames it was held, in place of the game's bar along the bottom.
• No forced input delay: the Wii U game waits two frames (33 ms) after reading a button before acting on it, in every mode (Cemu's "Reduce input lag" graphic pack removes it too). The port leaves that wait out; the launcher's Settings can put it back. Practice's own Input Delay setting works either way.
• Installs like any other program: ttt2 --install copies the game into a folder you choose and adds it to the application menu.
• Made to be modified: every function of the game is a C++ function that can be replaced (see below).

Status

Playable from boot through arcade mode. Not done yet: the Wii U GamePad's screen and speaker, online play, the software keyboard and error viewer screens, and audio effects the game does not seem to use. Only the European version with update 16 is supported (other versions have different code). Tested on Linux with an AMD GPU (RADV) under KDE Plasma (Wayland). Design notes, measurements and milestones are in docs/ARCHITECTURE.md.

The game

You need TEKKEN TAG TOURNAMENT 2 Wii U EDITION, European release, with update v16, as a .wua archive (Cemu can create one from an installed title; the update may be merged into the game's folder or stored beside it), or as a folder with the game's code/, content/ and meta/ and the update's files over them.

Property	Value
Product code	WUP-P-AKNP
Title ID	000500001010F800 (update 0005000E1010F800)
Version	16
code/Tekken.rpx SHA-256	fc0270465d384386f67804e48716e30bfbe85a5a1004e3a6bfe3ac75f9de5019

cafe-recomp refuses any other Tekken.rpx, and the port and its installer refuse a game whose executable is not the one they were built from.

Requirements

• Linux on x86-64 with AVX2 and FMA (x86-64-v3: Intel Haswell, AMD Excavator or newer).
• A Vulkan 1.3 GPU and driver with VK_EXT_external_memory_host and push descriptors (current AMD, Intel and NVIDIA drivers).
• To build: Git, CMake 3.20+, Ninja, Clang (or GCC 15+), Python 3, and the development files of SDL 3.2 or newer, shaderc, the Vulkan loader, Vulkan headers recent enough to define VK_KHR_present_wait2 (mid-2025 or newer), OpenSSL 3, zstd and zlib; for the launcher also GTK 4.10 or newer (without it the launcher is left out) and MinGW (optional: the Tekken 7 and Tekken 8 helpers are then built in).

On Arch Linux:

sudo pacman -S --needed base-devel git cmake ninja clang python zstd zlib openssl vulkan-headers vulkan-icd-loader sdl3 shaderc gtk4 mingw-w64-gcc

Other distributions package the same libraries under similar names; older releases such as Ubuntu 24.04 and Debian 12 ship SDL and Vulkan headers that are too old.

Building

git clone https://github.com/Petexy/Tekken-Tag-2-Ultimate-Edition.git && cd Tekken-Tag-2-Ultimate-Edition
python3 tools/setup_deps.py                      # ZArchive and AMD's addrlib, at pinned revisions

cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
cmake --build build --target wua_extract cafe-recomp

# The game's executables and metadata (about 70 MB per title folder) into local/wua
build/wua_extract extract-analysis "/path/to/TEKKEN TAG 2 Wii U EDITION (EU).wua" local/wua
# The v16 executable's code as C++ in generated/ttt2 (in the update's
# folder, or in the game's when the update is merged into it)
build/recomp/cafe-recomp local/wua/*_v16/code/Tekken.rpx generated/ttt2

cmake -B build -DTTT2_GENERATED_DIR="$PWD/generated/ttt2"
cmake --build build --target ttt2

Recompiling takes a few seconds; compiling the generated code takes a few minutes. local/, generated/, third_party/ and build*/ are ignored by Git, so nothing derived from the game ends up in a commit; keep captures and dumps from the debugging options under local/ too.

The launcher

Windows launcher

Starting from a release (Windows 10/11, x64):

1. Download Ultimate_Launcher-x86_64.exe from the newest release and put it in a folder of yours (not Program Files: it replaces itself when it updates).
2. Double-click it. The first start unpacks the launcher's files into %LOCALAPPDATA%\TTT2Ultimate\launcher and gets its private Python ready in a console window; later starts open the launcher at once. (When that path has letters beyond plain ASCII, as a user name such as José gives it, the files go to %PUBLIC%\TTT2Ultimate\launcher instead: see below.)
3. Continue with Set Up Game as in step 3 below. The tools, the build and the generated code stay in that folder too (plan its 30 GB on that drive).

The release launcher updates itself. When it starts (and when its window is back in front after six hours) it asks GitHub for this repository's newest release; when that is newer, a notice at the top of the window says so, with What's New (the release's page) and Update, and the button at the top right says Update to its version (that button also looks for an update any time). Update downloads the new .exe beside the one you started, checks it (its size, GitHub's SHA-256, that it is a 64-bit Windows launcher and says it is that version), puts it in that one's place and opens it: it unpacks its files over the old ones, keeping everything else there. Anything failing, or Cancel, leaves the .exe as it was. A game an older version built gets Update beside Play, which builds it again on this PC with the new version's changes. The launcher also says when main has newer changes than its release, as the Linux launcher does (below).

A test build (an .exe made on a branch other than main, for testers) follows its branch instead: when the branch has newer commits, the notice says so with Update, which downloads the newest commit's files from GitHub, puts them in place of the ones the .exe unpacked and opens the launcher again: a fix pushed to the branch reaches testers without a new .exe. A game built from older files then gets Update beside Play. One stopped half-way is unpacked again from the .exe when it is next started.

When Set Up Game or Update fails, the task panel names the checks that failed or the build's first error; Open Log there opens the whole log.

Starting from a downloaded project ZIP (Windows 10/11, x64):

1. Download this branch as a ZIP and Extract All into a writable folder whose path has only plain letters and is short, such as C:\TTT2: not in OneDrive (30 GB would be synced). Set Up Game refuses a path with letters such as à: CMake runs some build steps through batch files it writes in UTF-8, which cmd.exe reads in the console's code page, so such a letter turns into others and the step finds no folder.
2. Double-click Start Ultimate Launcher.cmd in that folder. The first start downloads and verifies a private Python/Tk runtime. No Python installation, Git installation, terminal commands or second project download are needed.
3. Click Set Up Game, select your own European Wii U TTT2 .wua containing update v16, and choose an installation folder.
4. Leave setup running while it downloads missing tools, prepares libraries, checks your game executable, builds and installs the Windows game.
5. Click Play when setup completes. To add fighters, open Steam, close T7/T8, select fighters and use Import / Update selected. Reina requires Tekken 8.

The first setup needs internet, a Vulkan-capable graphics driver, an x86-64-v3 CPU and substantial free disk space for the tools, generated build and game. It can take a while; keep the extracted project folder for future updates. Downloads are private to ignored local/ folders. Python, LLVM-MinGW and MinGit archives are SHA-256 pinned; Python packages are version pinned. Existing project files are reused; the game and its assets are never downloaded. Setup logs remain under the selected data folder. The game archive is kept.

The Windows build also produces build-windows-tools/ttt2-launcher.exe. This opens a separate Windows interface; the GTK launcher and Linux build/import paths are unchanged. The ZIP startup path obtains private Python/Tk automatically; developer launches can also use an installed Python 3 with Tcl/Tk. Setup obtains numpy and Pillow. Set TTT2_PYTHON to a Python executable to override automatic discovery.

The Windows interface looks and behaves as the Linux launcher: one page with the game (Play, Settings, Update when the launcher's version is newer than the game's) and its characters as the shared importer finds them (Tekken 7, Tekken 8 and Steam; Add, Update and Remove per fighter, Add All, the DLC with what Steam says you own), a Settings page (fullscreen, resolution, 120 fps, input delay, and the keyboard's keys chosen by pressing them, as the Linux launcher writes keyboard.ini), and the task panel below with its progress, Cancel and Details. Windows' own parts stay: Set Up Game, the More menu (Build / Rebuild, Install from Wii U Source, Update Installed Game, the logs) and the Folders in Settings. It calls the existing Windows build scripts, native installer, and shared character importer, and needs nothing beyond the Python with Tk it gets itself. Set Up Game prepares the build tools automatically from the extracted project. Keep the project folder for rebuilds. The compiled launcher executable can also be opened from its build folder after setup.

It detects the existing development archive, extracted title, fighter packs, saves, and CMake toolchain. Use Paths, then Save paths, to change them. Development configuration is saved in ignored local/windows-launcher.json; other layouts use %LOCALAPPDATA%/TTT2Ultimate/launcher.json. The data folder must end in TTT2Ultimate so runtime settings and launcher settings use the same place. Explicit fighter/save paths are passed to both the game and importer. Packs marked Update available still load: this compares revisions from the shared importer and never automatically rebuilds anything.

Task/game logs are saved under the selected data folder's logs/ directory; startup errors are saved beside the executable in launcher.log (the release .exe's in local/launcher.log of its folder in %LOCALAPPDATA%). Build/install tasks finish before the window closes. Import cancellation requests cleanup and keeps completed extraction data. Only the release .exe updates itself (a project ZIP is updated as a whole); this frontend does not implement the GTK key-capture screen or the Linux uninstall interface.

ttt2-launcher (Ultimate Launcher) does the installing and the adding of fighters in a window, without a terminal. Install… asks for your .wua and a folder, checks the PC, builds the game program for it from the archive and installs the game with its menu entry, as ttt2 --install does; then Play, Update (when the launcher's version differs from the program's) and Uninstall… (saves and added characters are kept unless you tick them; of a save folder you chose with TTT2_SAVE_DIR, only the game's own saves go). While the game runs, however it was started, Play, Update and Uninstall wait for it to end. What the game writes when Play starts it goes to ~/.cache/ttt2/game.log (of its last start); when it stops with an error, its last lines are shown under Play: attach that file to a report. The gear next to Play opens its Settings: whether the game starts fullscreen, the resolution it draws at, its 120 frames per second, whether fighters wait the Wii U version's two frames before acting on a button, and its keyboard keys (Playing). Its Characters section shows where Steam has Tekken 7 and Tekken 8, or why one cannot be used, and a part for each game's fighters (the installed game's first), with Add per fighter: Tekken 7's with Add All and its DLC fighters in a list that opens, with those your Steam account owns and Add All Owned; Tekken 8's (Reina, Azucena) without Tekken 7 or any of its fighters. Remove takes one out again. A Tekken 8 fighter whose moves could not be saved from Tekken 8 (a game update its helper does not know yet, or nothing to run it hidden) is added with Heihachi's moves, says so and why, and is offered as an update once their own can be saved. What all added fighters share is made from each one's own game, so while one game is uninstalled its fighters stay in the game but no other can be added: the launcher says so, and offers to remove that game's fighters all at once.

cmake --build build --target ttt2-launcher ttt2_kit
build/launcher/ttt2-launcher

Nothing of the game is in the launcher: the game program is built on your PC by the launcher's kit (build/launcher/kit: ttt2-build, cafe-recomp and the runtime) with your C++ compiler, in a few minutes. It needs Clang (or GCC 15+) and the SDL 3, shaderc, Vulkan, OpenSSL 3, zstd and zlib libraries (not their development files); the launcher checks the processor, the compiler and free space first and shows the command that installs what is missing. On image-based systems, whose package manager cannot add to the system (SteamOS, Fedora Atomic and Bazzite, openSUSE MicroOS and Aeon, NixOS), it says instead that the compiler and the importer's tools must come from a toolbox or distrobox container, or from the system's own way of adding software. build/launcher/kit/bin/ttt2-build install GAME FOLDER does the same in a terminal; ttt2-build check alone only checks that this PC can build the game program (the compiler, the libraries, and that the program links with them and starts).

To make an AppImage of the launcher (the launcher, its kit and the character importer; nothing of the game):

launcher/appimage/make_appimage.sh Ultimate_Launcher-x86_64.AppImage build-appimage

It builds in a folder of its own (here build-appimage; Git ignores it and the AppImage), needs LLD and mksquashfs, and downloads the AppImage runtime once (--runtime-cache DIR says where). The AppImage uses the system's GTK 4 (4.10 or newer) and needs glibc 2.38 and GCC 13's libstdc++ or newer (Ubuntu 24.04, Debian 13, Fedora 39 and newer releases, and rolling distributions), on any x86-64 processor. The game program it builds needs SDL 3.2 or newer from the system, which Ubuntu 24.04 does not have yet.

The AppImage updates itself. When it starts it asks GitHub for this repository's newest release; when that is newer, a notice at the top of the window says so, with What's New (the release's page) and Update, and the button left of Check Again is highlighted (that button also looks for an update any time). Update downloads the new AppImage (with curl or wget), checks it, puts it in place of the AppImage you started and opens it. A release is tagged v<version> (v0.1.1) with the AppImage and the Windows launcher attached, both built with that version as TTT2_LAUNCHER_VERSION in launcher/builder/CMakeLists.txt: before it replaces anything each launcher checks that the new one says it is that version (ttt2-launcher --version).

Both launchers also say when main has changes their buil