What you need to build a PSP homebrew app

Creating a homebrew process for PSP requires three things: a PSP console running custom firmware, a development kit on your computer, and knowledge of C programming. The PSP's architecture is well-documented by the homebrew community, and free tools exist to write, compile, and test your code before loading it onto the device.

Your PSP must be running custom firmware — not the original Sony firmware — because Sony's official system blocks unsigned applications. Custom firmware like Pro CFW or ME CFW allows you to run files from the Memory Stick without restriction. If your PSP is still on official firmware, you will need to install custom firmware first; that process depends on your PSP model and firmware version.

On your computer, you will install the PSP SDK (Software Development Kit), which includes a C compiler, libraries, and build tools. The most common choice is the open-source PSPSDK, which works on Windows, macOS, and Linux. You will also need a text editor or IDE to write code — many developers use Visual Studio Code or Code::Blocks because they are free and support the PSP toolchain.

Key Takeaways

  • Your PSP must run custom firmware to load and run homebrew applications, which the original Sony firmware blocks.
  • The PSPSDK is a free development kit that includes a compiler and libraries; you install it on your computer, not on the PSP.
  • Homebrew apps are written in C, compiled into EBOOT.PBP files, and transferred to your PSP's Memory Stick in a specific folder structure.
  • Testing happens on your PSP itself — you load the app from the custom firmware menu and run it like any other program.
  • The PSP homebrew community maintains documentation and example code that show how to use graphics, sound, and input on the PSP hardware.

Installing the PSPSDK on your computer

The PSPSDK setup differs by operating system. On Windows, the fastest route is to read a pre-built toolchain package from the PSP homebrew community rather than compiling from source. Sites like GitHub host ready-to-use versions that include the compiler, libraries, and build scripts in one read. Extract the folder to a location like C:\pspsdk and add it to your system PATH so your computer can find the compiler from any folder.

On macOS and Linux, you can install PSPSDK through package managers or build it yourself. Many developers use Homebrew on macOS to install the toolchain in a few commands. Linux users often compile from source using the official PSPSDK repository, which takes longer but gives you full control over the installation. Whichever method you choose, verify the installation by opening a terminal or command prompt and typing psp-gcc --version — if you see a version number, the compiler is ready.

After installation, create a folder on your computer where you will keep your projects. Inside that folder, create a straightforward test project with a main.c file and a Makefile — the Makefile tells the compiler how to build your code. The PSP homebrew community provides template Makefiles that you can copy and modify for each new project.

Writing and compiling your first app

A minimal PSP app in C includes headers that tell the compiler about the PSP hardware, a main function that runs when the app starts, and a callback function that handles the PSP's shutdown request. The simplest working example prints text to the screen, waits for button input, and exits when you press a button. This teaches you the basic pattern: initialize the graphics system, draw something, read input, and clean up.

To compile, open a terminal or command prompt in your project folder and run make. The Makefile calls the PSP compiler (psp-gcc) and creates an EBOOT.PBP file — this is the executable that your PSP will run. If there are errors, the compiler prints them to the screen; common mistakes are missing semicolons, undefined variables, or incorrect header names. Fix the error in your source code and run make again.

Once compilation succeeds, you have a folder called EBOOT.PBP inside a %PSP%/GAME/ structure. This folder structure matters: your PSP's custom firmware looks for apps in PSP/GAME/ on the Memory Stick, and each app needs its own subfolder with an EBOOT.PBP file inside. Copy the entire folder to your Memory Stick using a USB cable or card reader.

Loading and testing your app on the PSP

Connect your PSP to your computer with a USB cable and enable USB mode on the device — the PSP will show a menu asking whether to connect. Your computer will see the Memory Stick as a removable drive. Navigate to PSP/GAME/ and paste your app's folder there. Disconnect the PSP and exit USB mode.

On the PSP, go to the Game menu and look for your app in the list — it will appear with the name you gave it in the Makefile. Select it and press X to run. If the app crashes or does nothing, check the PSP's debug output by connecting to your computer with a USB cable and running a debug tool like pspsh from the PSPSDK. The debug output shows error messages that tell you what went wrong.

Testing is iterative: you write code, compile, copy to the Memory Stick, run on the PSP, see what breaks, and repeat. Many developers speed this up by using a Memory Stick adapter and keeping the PSP connected to their computer, so they can copy new builds without unplugging and replugging the device each time.

Using graphics, sound, and input in your app

The PSPSDK includes libraries for drawing graphics, playing sound, and reading button input. The most common graphics library is libgu, which lets you draw 2D sprites and 3D models. To draw a sprite, you load an image file (usually PNG or BMP), create a texture from it, and tell libgu where to draw it on screen. The PSP's screen is 480 pixels wide and 272 pixels tall.

For sound, the libpspau library plays WAV files and lets you control volume and playback. You load a WAV file into memory, create an audio channel, and tell it to play. The PSP has stereo speakers and a headphone jack, so you can test audio output both ways.

Button input comes from the libpspctrl library, which reads the D-pad, analog stick, and all face buttons. In your main loop, you call a function to read the current button state, check which buttons are pressed, and respond accordingly. This is how you make your app respond to user input — for example, moving a sprite when the player presses the D-pad.

Common problems and how to fix them

The most frequent issue is a missing or incorrect Makefile. If make returns "command not found" or "Makefile not found", check that the Makefile is in your project folder and spelled exactly as Makefile with a capital M. If the compiler cannot find a library header, you may have installed the PSPSDK incompletely — reinstall it and verify that the PATH is set correctly.

Apps that compile but crash on the PSP usually have a bug in the code itself. Use the debug output to see where the crash happens, then add print statements to narrow down the problem. A common mistake is reading input or drawing graphics before initializing the graphics system — the order matters.

If your app runs but looks wrong — graphics are distorted, colors are wrong, or text is unreadable — the issue is usually in how you set up the graphics mode or how you load textures. The PSP uses a specific pixel format for textures, and if you load an image in the wrong format, it will display incorrectly. Check the example code in the PSPSDK documentation to see the correct setup.

Where to find code examples and documentation

The official PSPSDK repository on GitHub includes example programs for graphics, sound, input, and networking. These examples are the fastest way to learn how to use each library — you can read the code, compile it, run it on your PSP, and modify it to experiment. The PSP homebrew wiki also documents the libraries and provides tutorials for common tasks.

The PSP Homebrew Community on forums like PSPHacks and Reddit's r/PSP can answer questions when you get stuck. Many developers who built PSP apps years ago still participate in these communities and remember the quirks of the hardware. If you post your error message and the relevant code, someone will usually spot the problem.

Frequently Asked Questions

Do I need a specific PSP model to run homebrew?

Most PSP models can run custom firmware, but the process and compatibility vary by model and firmware version. PSP-1000 and PSP-2000 models are easiest to modify. PSP-3000 and PSPgo are more difficult. Check the custom firmware documentation for your specific model before starting.

Can I publish my homebrew app on the PSP Store?

No. The PSP Store is closed and only runs official Sony software. Homebrew apps are distributed through community sites, GitHub, and forums. You can share your EBOOT.PBP file freely, and other users can copy it to their Memory Stick and run it on their own PSP.

What if I want to make a game instead of a straightforward app?

Games use the same libraries and development process as any other app. You write a main loop that reads input, updates game state, and draws the screen every frame. The PSP runs at 60 frames per second, so your loop should complete in about 16 milliseconds per frame. Many developers use game engines like Lua or frameworks built on top of libgu to speed up game development.

Can I use C++ instead of C?

Yes. The PSPSDK includes a C++ compiler (psp-g++), and you can write apps in C++ using the same libraries. C++ adds object-oriented features but also adds complexity; most beginners start with C to learn the hardware first.

How do I add music or sound effects to my app?

Use libpspau to load and play WAV files. Create your audio files in a standard WAV format, place them in your project folder, and load them at startup. In your code, call the library functions to play, pause, or stop the audio. The PSP can play multiple sounds at once if you create multiple audio channels.