What you need to build PSP homebrew

Creating homebrew applications for PSP requires three things: a PSP console that can run unsigned code, a computer with development tools installed, and knowledge of C or C++ programming. The PSP must be running custom firmware — not the official Sony firmware — because Sony's system blocks any code that isn't digitally signed by the company.

Your computer needs the PSP SDK (Software Development Kit), which is a free collection of compilers, libraries, and tools that translate your code into something the PSP can run. The SDK works on Windows, Mac, and Linux. You'll also need a text editor or IDE (integrated development environment) to write your code, and a way to transfer files from your computer to your PSP — usually a USB cable.

If you've never programmed before, expect a steep learning curve. Homebrew development assumes you already know how to write C or C++ code and understand basic concepts like functions, loops, and memory management. There are tutorials and communities that can help, but they won't teach you programming from zero.

Key Takeaways

  • Your PSP must run custom firmware before it can execute homebrew; official Sony firmware will reject unsigned applications.
  • The PSP SDK is free and runs on Windows, Mac, and Linux, but requires you to already know C or C++ programming.
  • Most homebrew starts as a folder containing your source code files, a makefile that tells the compiler what to build, and a EBOOT.PBP file that the PSP recognizes as an application.
  • Testing happens on your computer first using an emulator, then on the actual PSP by copying files to the PSP's GAME folder via USB.
  • Common mistakes include forgetting to compile before transferring files, using incompatible library versions, and not understanding how the PSP's hardware handles graphics and sound.

Setting up the PSP SDK on your computer

Start by downloading the PSP SDK for your operating system. The most commonly used version is PSPSDK, which you can find through the official PSP homebrew community sites. On Windows, many developers use a pre-packaged version called PSPToolchain that bundles everything together, which saves you from installing each component separately.

After downloading, follow the installation instructions for your system. On Windows, this usually means running an installer and choosing where to put the files. On Mac and Linux, you'll typically extract files and run setup scripts from the terminal. The installation can take 20 to 30 minutes depending on your internet speed, because the SDK downloads compilers and libraries.

Once installed, test that the SDK works by opening a terminal or command prompt and typing a command like psp-gcc --version. If you see a version number, the SDK is ready. If you get an error, the installation didn't complete correctly — check that the SDK folder is in your system's PATH, which tells your computer where to find the tools.

Creating your first homebrew project structure

Every PSP homebrew project needs a specific folder layout. Create a main folder for your project, then inside it create subfolders called src (for your C code), build (where compiled files go), and bin (where the final EBOOT.PBP file ends up). You'll also need a makefile in the main folder — this is a text file that tells the compiler how to build your project.

The makefile is the most confusing part for beginners because it uses a specific syntax that looks nothing like C code. It lists your source files, tells the compiler which libraries to link, and defines the build process. Most developers copy a template makefile from an existing project and modify it for their own code. The makefile needs to know your project name, which source files to compile, and which PSP libraries you're using.

Your main code file goes in the src folder and is usually called main.c. This file must include a function called main() where your program starts, just like any C program. You'll also need to include PSP-specific headers at the top of your code that give you access to PSP functions for graphics, sound, and input.

Writing code that the PSP can actually run

PSP programming is different from writing programs for a computer because the PSP has much less memory and processing power. You can't use standard graphics libraries like OpenGL directly — instead, you use the PSP's built-in graphics functions, which are much faster but require you to think differently about drawing to the screen.

The most common approach is to use a library called SDL (Simple DirectMedia Layer) or GU (Graphics Unit), which are both ported to PSP. SDL is easier to learn if you've done graphics programming before, because it works similarly on computers. GU is faster but requires more knowledge of how the PSP's hardware actually works. Many beginner projects use SDL because the learning curve is gentler.

Input on PSP works through button polling — your code repeatedly checks which buttons are pressed and responds. There's no mouse or keyboard, so you're reading the D-pad, analog stick, and face buttons. Sound requires loading audio files and playing them through the PSP's audio system, which is straightforward but needs you to understand audio formats like WAV or OGG.

A critical mistake beginners make is trying to do too much in one frame. The PSP screen refreshes 60 times per second, so your code needs to run fast enough to update the screen, check input, and play sound all within 16 milliseconds. If your code is too slow, the screen will stutter or freeze. This is why memory management and efficient code matter on PSP — you can't just write sloppy code and hope it works.

Compiling your code into a PSP application

Once you've written your code and created your makefile, open a terminal or command prompt, navigate to your project folder, and type make. The compiler will read your makefile, compile all your C files into object files, link them together, and create the final EBOOT.PBP file in your bin folder. This process usually takes a few seconds.

If the compiler finds errors in your code, it will print messages telling you what's wrong and which line the problem is on. Common errors include forgetting semicolons, misspelling function names, or using variables you haven't declared. Fix the errors, save your file, and run make again. If the compile succeeds, you'll see no error messages and the EBOOT.PBP file will be created.

If compilation fails and you can't figure out why, copy the error message and search for it in PSP homebrew forums. Most common errors have been solved before, and someone in the community has posted the answer. Don't try to guess — error messages are usually specific enough that searching for them directly works.

Testing on your computer before moving to PSP

Before copying your application to the actual PSP, test it on your computer using an emulator. The most widely used PSP emulator is PPSSPP, which is free and runs on Windows, Mac, Linux, and even Android. Download it, then open your EBOOT.PBP file in PPSSPP to see if your application runs.

Testing on an emulator catches most bugs before you transfer to the PSP. You can see if graphics display correctly, if buttons respond, and if the program crashes. The emulator isn't perfect — some things work differently on real hardware — but it's much faster than constantly copying files to your PSP and testing there.

If your application crashes in the emulator, PPSSPP can show you a debug log that tells you where the crash happened. This is invaluable for finding problems. If it runs fine in the emulator but crashes on the real PSP, the issue is usually related to memory or timing — something that behaves differently on actual hardware.

Installing and running your homebrew on PSP

Connect your PSP to your computer with a USB cable. The PSP should appear as a removable drive. Navigate to the PSP/GAME folder on the PSP's memory card. Create a new folder with a name like MYHOMEBREW (the name doesn't matter much, but it should be uppercase). Copy your EBOOT.PBP file into this folder.

Disconnect the PSP and look in the Game menu. Your homebrew should appear as a new icon. Select it and press X to launch. If it doesn't appear, make sure the EBOOT.PBP file is directly in the folder you created — it can't be in a subfolder. Also check that your PSP is actually running custom firmware; if you're running official Sony firmware, homebrew won't show up at all.

If your application crashes on the PSP, you won't get an error message like you would on a computer — the PSP will just return to the menu. This is why testing in the emulator first is so important. If it works in the emulator but crashes on PSP, try adding debug output that writes to a log file, then check that file to see where the crash happened.

Common problems and how to fix them

The most frequent issue is forgetting to recompile after changing your code. You edit a C file, copy the EBOOT.PBP to your PSP, and nothing changes. The solution is always to run make again before copying. Make a habit of compiling, testing in the emulator, then transferring to PSP.

Another common problem is library version mismatches. If you download code from someone else's project and try to compile it, you might get errors because they used a different version of the SDK or a library you don't have installed. The fix is usually to update your SDK or install the missing library, but sometimes you need to modify the makefile or code to work with your version.

Graphics often appear wrong because the PSP's coordinate system or color format is different from what you expected. If colors look inverted or graphics are stretched, check your code for how you're setting up the graphics mode and how you're specifying colors. The PSP uses BGR format for colors instead of RGB, which catches a lot of beginners.

Sound not playing usually means the audio file format is wrong or the file path is incorrect. The PSP can play WAV and OGG files, but not MP3 without extra libraries. Make sure your audio files are in a folder the PSP can find, and that your code is using the correct path.

Frequently Asked Questions

Do I need to know how to program before I start making PSP homebrew?

Yes. Homebrew development assumes you already know C or C++ and understand programming concepts. If you're brand new to programming, learn the basics on a computer first — there are many free tutorials online. Once you're comfortable with C, PSP-specific learning is much easier.

Can I make homebrew without custom firmware on my PSP?

No. Official Sony firmware blocks all unsigned code. Your PSP must run custom firmware before it can run any homebrew. If your PSP is running the latest official firmware, you'll need to downgrade or use a modchip, which is beyond the scope of development itself.

What kind of applications can I make for PSP?

Anything that fits in the PSP's memory and processing power. Most homebrew is games, but people have made media players, emulators, productivity tools, and demos. The limit is your programming skill and how much time you want to spend. Simple 2D games are a good starting point.

Can I sell my PSP homebrew?

Technically yes, but almost nobody does. The PSP market is tiny now, and most homebrew developers share their work for free. If you use libraries or code from other people, check their licenses — many require you to share your code for free too.

Where do I find help if I get stuck?

The PSP homebrew community is still active on forums and Discord servers dedicated to PSP development. Search for "PSP SDK help" or "PSPSDK forum" to find places where developers answer questions. GitHub also has many example projects you can learn from by reading their code.