PSPC

Guide · Linux · Source build

PSPC on Linux

The Linux port is included in PSPC 0.1.2's source: the runtime, an OpenGL renderer and a native GTK launcher. The release publishes only the Windows installer; Linux must be built from source and is not yet at parity with Windows.

Source only No Linux download is published with v0.1.2. These steps build the v0.1.2 tag, not the changing main branch. The port is checked by CI, but its scoped checks don't establish full Windows parity.

Where the port stands

The Linux runtime, the OpenGL renderer and a native GTK launcher build from source and pass the port's own checks. Validated so far:

  • Builds on Fedora 44 (GCC 16) and on Ubuntu 22.04 under WSL (GCC 11).
  • pspautotests: the same 539 of 559 as on Windows, with no unexpected failures.
  • The GTK launcher's workflows: settings and plugins, accounts and servers, building native code and playing, installing Sony's 4.01 firmware and booting the XMB, and starting a game from the XMB and returning to it.

It is not yet a supported release: there are no prebuilt packages, and it is not at parity with Windows. See what isn't covered yet.

What you need

  • A 64-bit Linux PC.
  • A C++20 compiler (GCC or Clang), CMake 3.21 or later, Ninja, Python 3 and pkg-config.
  • Development packages for SDL2, FFmpeg (libavcodec, libavutil, libswresample, libswscale), FreeType, fontconfig, libcurl 7.85 or later, GTK 3.22 or later, and OpenGL.
  • Clang, for building games' native code from the launcher.

Check your versions. Ubuntu 22.04's curl and FFmpeg packages are too old for PSPC; its validation used newer versions built from source. Fedora 44's packages work.

Build PSPC

$ git clone --branch v0.1.2 --depth 1 https://github.com/Gattic/PSPC.git && cd PSPC
$ cmake -S . -B build/LinuxRuntime -G Ninja \
    -DCMAKE_BUILD_TYPE=RelWithDebInfo -DPSPC_BUILD_RUNTIME=ON
$ cmake --build build/LinuxRuntime --parallel 4

That builds pspc, the pspc-launcher, the recompiler and the decryption tool into build/LinuxRuntime/bin. To run the test suite as well: ctest --test-dir build/LinuxRuntime --output-on-failure.

The GTK launcher

$ build/LinuxRuntime/bin/pspc-launcher

It lists the games in ~/.local/share/pspc/Games; Games folder picks another folder, or pass one on the command line: pspc-launcher ~/PSP. The GTK launcher isn't a copy of the Windows one, but it has the same features:

  • The library: search by title or disc ID, icons and artwork, and the native code status of each game.
  • Play, Interpreter, Rebuild native, Cancel build and Stop game. When a game's native code is missing, partial or stale, Play asks whether to Build and play, Use available code or run in the Interpreter.
  • Settings / Input, Plugins, Account / Friends and Online / Servers, as described in the other guides.
  • Boot XMB and Firmware Manager: see profiles and the Firmware Manager.

Where PSPC keeps your files

On Linux, PSPC follows the XDG base directories and never writes into its installation:

FolderHolds
~/.config/pspcpspc.ini, and your infrastructure.json server redirects
~/.local/share/pspcThe memory stick (ms0, with your saves), firmware profiles, Games, plugins, screenshots and server databases
~/.cache/pspcNative code (aot) and decrypted modules: rebuildable
~/.local/state/pspcLauncher, game and server logs

Setting XDG_CONFIG_HOME, XDG_DATA_HOME, XDG_CACHE_HOME or XDG_STATE_HOME to an absolute path moves the matching folder.

Graphics on Linux

The default renderer is the software renderer, as on Windows. The GPU renderer on Linux is OpenGL (renderer=opengl, or --renderer opengl), with the same 1× to 16× resolutions, texture filtering and xBR upscaling as Direct3D 11. Transform, lighting and clipping run on the GPU here too, bit for bit as on the CPU.

It needs OpenGL 4.5 with the GL_ARB_fragment_shader_interlock extension. On a driver without it, PSPC says so and uses the software renderer. It has been tested on Mesa with Intel graphics; other drivers and retail gameplay at speed haven't been checked yet.

On Wayland, leaving fullscreen may not restore the window exactly with some SDL versions. An optional local SDL build fixes that without replacing your system's SDL.

Install it as an application

A runtime build can install a complete, relocatable application folder, or pack it into a .tar.gz. It contains the runtime, the launcher, the native-code tools and the servers, and uses your system's libraries, Python and compiler.

$ cmake --install build/LinuxRuntime --prefix "$HOME/Applications/PSPC-0.1.2"
$ python3 -I "$HOME/Applications/PSPC-0.1.2/tools/pspc_desktop.py" install

The second command adds PSPC to your application menu, for your user only, without sudo. Install into an empty, dedicated folder rather than /usr, named for the tag you built. The packaging guide covers the archive, updates and removal.

Not covered yet

These haven't been validated on Linux, so expect rough edges:

  • Broad retail gameplay with native code, and OpenGL rendering of retail games at full speed.
  • Physical controllers, and audio quality and synchronization.
  • Distributions, desktops and GPU drivers beyond those above.
  • Prebuilt packages: the archive needs your system's libraries and is not an AppImage.

The Linux port status at v0.1.2 records every check, with its evidence and limits.