RPCS3 failed to compile fragment shader Little Big Planet Fixes

You get LBP running on RPCS3. Maybe it boots, maybe it gets partway through loading, maybe it crashes mid-level. Either way, you check the log, and there it is: “Failed to compile fragment shader.”

The game locks up. RPCS3 hangs or closes. Agent 47 isn’t here to help you this time.

Fragment shader compilation failures in LBP on RPCS3 are genuinely common, and the fix isn’t always the same one. Little Big Planet has always been a beast to emulate. Its rendering pipeline does unusual things with the PS3’s RSX GPU that push RPCS3’s shader recompiler to its limits. Add in differences between Nvidia, AMD, and Intel GPUs, and you get a fix that works for one person and does nothing for another.

Emulator rendering issues are often connected to corrupted graphics caches or outdated rendering components. If you are troubleshooting broader game execution problems, check our advanced game launch and rendering error fix guide for additional stability solutions.

This guide covers every known cause in the order you should try them.

What “failed to compile fragment shader” actually means

Quick version: RPCS3 takes the shader programs that ran on the PS3’s RSX GPU and recompiles them into shaders your PC’s GPU understands, either GLSL for OpenGL or SPIR-V for Vulkan. When that recompilation breaks, the game can’t render the frame it needs and crashes.

The failure can happen because:

• Your GPU driver doesn’t support something in the compiled shader
• RPCS3’s shader recompiler generated broken output for a specific shader
• The shader cache is corrupted
• RPCS3’s settings don’t match what LBP needs
• Your RPCS3 build is outdated and contains a bug that’s already been fixed

Every one of those has a different fix. Start from the top and work down.

Fix 1: Update RPCS3 to the latest build

This is the single most important step and the one people skip most often.

RPCS3 ships multiple builds per week. Shader recompiler bugs get patched fast. A fragment shader error that crashes LBP on a 3-month-old build might already be fixed in this week’s build.

Go to rpcs3.net/download. Download the latest build. Extract it and replace your existing RPCS3 folder. Your game data, saves, and settings are stored separately under %APPDATA%\rpcs3 by default, so updating the emulator doesn’t wipe them.

After updating, launch LBP again and test before doing anything else. If the crash is gone, you’re done.

If you’re already on the latest build, or updating didn’t help, continue.

Fix 2: Update your GPU drivers

RPCS3’s shader compiler output has to be accepted by your GPU driver’s own compiler. Old drivers sometimes reject valid shader code or compile it incorrectly.

NVIDIA: Go to nvidia.com/drivers or use GeForce Experience. Get the latest Game Ready Driver.

AMD: Go to amd.com/support or use AMD Software: Adrenalin Edition. Get the latest driver for your GPU model.

Intel Arc / Intel integrated: Go to intel.com/content/www/us/en/download-center and grab the latest graphics driver.

After installing, do a clean install. For Nvidia, the installer has a “Custom Installation” option with a “Perform a clean installation” checkbox. For AMD, use DDU (Display Driver Uninstaller) to fully wipe the old driver before installing a fresh.

Reboot, launch RPCS3, test LBP.

Fix 3: Switch between Vulkan and OpenGL

Little Big Planet on RPCS3 behaves differently under Vulkan vs OpenGL. On some GPU and driver combinations, one works and the other throws the fragment shader error.

Open RPCS3. Go to Configuration (or right-click LBP and choose “Change Custom Configuration”). Go to the GPU tab. Change the Renderer.

Shader compilation failures in RPCS3 are frequently tied to outdated GPU drivers or DirectX/Vulkan conflicts. You may also find our game performance and system compatibility troubleshooting guide useful when diagnosing graphics-related crashes and launch issues.

If you’re on Vulkan, switch to OpenGL. If you’re on OpenGL, switch to Vulkan.

General guidance:

• NVIDIA GPUs: Vulkan usually works better, but OpenGL is worth trying if Vulkan fails
• AMD GPUs on Windows: Vulkan tends to be more stable for LBP specifically
• AMD GPUs on Linux: Mesa’s Vulkan (RADV) or OpenGL (RadeonSI) both work well; RADV often handles LBP shaders better
• Intel Arc: Vulkan is preferred; Intel’s OpenGL driver has more rough edges on RPCS3

Test each renderer. The fragment shader error that kills LBP under one renderer often doesn’t appear under the other.

Fix 4: Delete the shader cache

RPCS3 builds a shader cache as it compiles shaders during gameplay. If that cache got corrupted, a bad cached shader gets loaded every time instead of being recompiled fresh, and the crash repeats.

Close RPCS3 completely.

Navigate to your RPCS3 data folder. Default location:

%APPDATA%\rpcs3\cache\

Inside, find a folder with LBP’s game ID. Little Big Planet 1 is BCUS98208 for the US version, BCES00141 for the European version. LBP2 is BCUS98245 (US) or BCES01086 (EU).

Delete the folder matching your game’s ID. Or delete just the shaders_cache subfolder inside it if you want to keep other cached data.

Relaunch RPCS3 and LBP. It’ll recompile shaders from scratch. The first few minutes will be stuttery while it builds the cache fresh. That’s normal. Give it time before concluding the fix didn’t work.

Fix 5: Apply the recommended LBP settings in RPCS3

Little Big Planet has well-documented recommended settings in the RPCS3 compatibility list. Using wrong settings causes shader errors and other crashes.

Right-click Little Big Planet in the RPCS3 game list. Choose “Create Custom Configuration.” Go through each tab:

CPU tab:

• PPU Decoder: LLVM Recompiler
• SPU Decoder: LLVM Recompiler
• SPU Block Size: Mega (improves performance and stability)
• Preferred SPU Threads: 0 (auto) or match your CPU core count

GPU tab:

• Renderer: Vulkan (or OpenGL if Vulkan fails for you)
• Frame limit: 30 or 60, depending on your preference; Auto is fine
• Write Color Buffers: ON (this one matters a lot for LBP)
• Read Color Buffers: OFF unless you have specific visual glitches
• Shader Mode: Async (multi-threaded) for less stuttering, or Recompiler (single-threaded) if async causes crashes
• Disable Vertex Cache: OFF (leave it default unless you have artifacts)
• Anisotropic Filter: Auto or 4x

Audio tab:

• Audio Backend: Cubeb (most stable across platforms)

Advanced tab:

• Driver Wake-Up Delay: 20 to 200µs if you’re getting RSX FIFO errors in the log alongside the shader error

Check the RPCS3 wiki page for LBP specifically (wiki.rpcs3.net) for the most current recommended settings. The wiki updates when settings change and is maintained by people who’ve spent serious time on each game’s compatibility.

Fix 6: Enable or disable “Write Color Buffers.”

This setting deserves its own section because it’s the single setting most directly tied to LBP’s rendering behavior.

Little Big Planet uses color buffer feedback in its rendering pipeline, which is unusual. The PS3’s RSX could read back from its own color buffers mid-render. RPCS3’s “Write Color Buffers” option emulates this behavior.

With it off, LBP’s shaders sometimes get handed data they don’t expect, which can produce a fragment shader compilation failure because the shader output is invalid for the current state.

With it on, the emulation more closely matches what the PS3 actually did, and the shaders compile against a state that makes sense.

Go to your custom LBP configuration, GPU tab. Make sure “Write Color Buffers” is checked ON. Apply and restart the game.

If you already have it on and still get the error, try turning it off briefly to test. Some specific shader errors in certain LBP levels actually go away without it, depending on your GPU and driver.

Fix 7: Change the shader compilation mode

RPCS3 has multiple shader compilation modes:

• Recompiler (LLVM): Compiles shaders synchronously, one at a time. Slower during initial play but very stable.
• Async (multi-threaded): Compiles shaders in background threads while the game runs. Faster, but it can crash if a shader that’s still compiling gets referenced before it’s ready.
• Async with shader interpreter: Uses a software fallback while shaders compile in the background. Most stuttery but least likely to crash.

If you’re on Async mode and getting fragment shader failures, switch to the LLVM recompiler. The synchronous mode is more stable for LBP’s shader workload even though it causes more hitching during first-time play.

GPU tab, Shader Mode. Try each one. For a lot of LBP players, switching from Async to the single-threaded recompiler stops the fragment shader crash entirely.

Fix 8: Check the RPCS3 log for the specific shader

When RPCS3 fails to compile a shader, it logs more details than just the error message in the game window. The log file tells you exactly which shader failed and sometimes why.

Find the RPCS3 log:

%APPDATA%\rpcs3\RPCS3.log

Open it in a text editor after the crash. Search for “fragment shader,” or “compile,” or “RSX.” You’ll find lines like:

E RSX: Fragment shader recompilation failed: [shader hash]

E RSX: GLSL error: [error detail]

The GLSL or SPIR-V error detail is the useful part. Common ones:

• error: use of undeclared identifier → Usually a driver bug or mismatch; try switching renderer
• error: too many temporary registers → GPU driver can’t handle the shader complexity; try updating drivers or switching from OpenGL to Vulkan
• Shader compilation timed out → The shader is too complex for your GPU to compile in time; try LLVM recompiler mode
• SPIR-V validation error → The Vulkan shader output from RPCS3 is invalid; usually fixed by updating RPCS3

Post the specific error to the RPCS3 Discord or GitHub issues if you find an error you can’t match to a fix. The developers actively look at these.

Fix 9: GPU-specific fixes for AMD

AMD GPUs have a specific set of LBP shader issues worth calling out separately.

On Windows with AMD: The AMD OpenGL driver has historically had issues with the GLSL shaders RPCS3 generates for LBP. If you’re on AMD and OpenGL, switch to Vulkan first.

RADV on Linux: Mesa’s RADV Vulkan driver handles RPCS3’s shader output very well. If you’re on Linux with an AMD GPU, make sure you’re using RADV and not AMDVLK. Check with:

vulkaninfo | grep driverName

RADV shows radv. AMDVLK shows the AMD open-source driver. RADV is generally better for RPCS3.

AMD shader cache on Windows: AMD’s driver maintains its own shader cache separately from RPCS3’s cache. If this gets corrupted, it can cause repeated fragment shader failures even after you delete RPCS3’s cache.

Clear AMD’s shader cache: open AMD Software (Adrenalin Edition), go to Settings, Graphics, and look for “Reset Shader Cache” or “Delete Shader Cache.” The exact location varies by driver version. Alternatively, delete the contents of:

%LOCALAPPDATA%\AMD\DxcCache

%LOCALAPPDATA%\AMD\GLCache

After clearing, relaunch RPCS3 and LBP.

Fix 10: GPU-specific fixes for Nvidia

NVIDIA’s driver has its own shader cache too. On RPCS3, Nvidia GPUs are generally the most compatible, but old driver shader caches can cause problems.

Clear Nvidia’s shader cache. Go to:

%LOCALAPPDATA%\NVIDIA\DXCache

%LOCALAPPDATA%\NVIDIA\GLCache

%APPDATA%\NVIDIA\ComputeCache

Delete the contents of those folders (not the folders themselves). Relaunch RPCS3.

Also, check the Nvidia Control Panel. Some users have Threaded Optimization set to Off globally, which can affect how RPCS3’s shader compilation threads work. Set it to Auto or On for rpcs3.exe specifically.

Right-click desktop, Nvidia Control Panel, Manage 3D Settings, Program Settings. Add rpcs3.exe. Set Threaded Optimization to On.

Fix 11: Vulkan validation layers interfering

If you have the Vulkan SDK installed (common if you do any graphics development), the validation layers might be active globally and intercepting RPCS3’s Vulkan calls. Validation layers add overhead and sometimes reject shader output that real drivers accept.

Check if validation layers are enabled:

Look for a vk_layer_settings.txt or check your environment variables for VK_INSTANCE_LAYERS or ENABLE_VULKAN_RENDERDOC_CAPTURE. If either of those is set, disable them.

Also, check if RenderDoc is running in the background. RenderDoc injects a Vulkan layer into every Vulkan app on the system when it’s open. Close RenderDoc completely if it’s running.

Fix 12: Verify your PS3 firmware and game dump

RPCS3 requires PS3 firmware to run games. If your firmware install is corrupted or incomplete, some shader-related system modules fail to load, which can look like a fragment shader compilation failure even though the real problem is upstream.

In RPCS3, go to File, Install Firmware. Reinstall the PS3 firmware (get it from PlayStation’s official site). Let the installation complete fully.

Also, check the integrity of your LBP game dump. A bad game dump can have corrupted shader programs baked into the game files themselves. If your dump came from a sketchy source or a disc that was scratched, the shader programs in the game’s EBOOT might be partially corrupted.

If you have access to the original disc, re-dump it with a clean PS3 using a dumping tool. Compare the file hashes if you have a known-good dump to check against.

Fix 13: RPCS3 experimental settings that help LBP

A few settings in RPCS3’s advanced and debug menus specifically help with LBP stability:

Driver Wake-Up Delay: Go to the Advanced tab in the custom configuration. Set this to somewhere between 20 and 200 microseconds. LBP’s RSX command stream is unusually intensive, and a small delay here reduces RSX FIFO errors that sometimes appear alongside shader failures.

Accurate RSX reservation access: In the Advanced tab, try enabling this. It adds CPU overhead but makes RSX emulation more accurate, which can stabilize shader behavior in LBP.

Disable ZCull Occlusion Queries: On the GPU tab, try enabling this option. LBP uses occlusion queries in some areas, and RPCS3’s ZCull emulation occasionally feeds bad data into the rendering pipeline right before a shader compilation.

Shader Precision: If you see this option, try “High” precision. Lower precision can produce shaders with floating-point handling that some GPU drivers reject.

Little Big Planet 1 vs LBP2 vs LBP3: different problems

Worth knowing which game you’re on because the shader issues differ.

LBP1: The most emulation-mature of the three. Most fragment shader issues are driver or settings-related. The fixes in this guide apply directly.

LBP2: More complex renderer, more shaders, more opportunities for compilation failure. The Write Color Buffers setting is especially important for LBP2. SPU accuracy settings matter more here, too.

LBP3: Worst compatibility. LBP3 was developed by Sumo Digital rather than Media Molecule and uses a more complex and less-documented rendering approach. Fragment shader errors in LBP3 are harder to fix and sometimes aren’t fixable on current RPCS3 builds. Check the RPCS3 compatibility page for LBP3’s current status before spending hours troubleshooting what might be a known, unfixed bug.

Reading the RPCS3 compatibility list

Before deep-diving into configuration, always check wiki.rpcs3.net and search for your specific game and region version.

The compatibility list shows:

• Current playable status (Playable, Ingame, Intro, Loadable, Nothing)
• Which game region versions work best
• Known issues
• Recommended settings that the community has verified

LBP1’s US and EU versions have different compatibility histories. Some region versions hit the fragment shader error more than others because the shader programs differ slightly between regions. If you’re on a version that’s listed as having known shader issues, try a different region dump if you have access to one.

Diagnostic checklist: narrow it down fast

Run through this before spending an hour on individual fixes:

1. Is RPCS3 up to date? Download the latest build and test first.
2. Are the GPU drivers current? Update and do a clean install.
3. Have you tried both Vulkan and OpenGL? Swap renderers and test each.
4. Is the shader cache deleted? Delete it and let it rebuild.
5. Is Write Color Buffers enabled? Turn it on in GPU settings.
6. What does the log say? Open RPCS3.log and search for the specific shader error.
7. Are you using custom LBP settings? Apply the recommended settings from the RPCS3 wiki.
8. Are you on LBP3? Check the current compatibility status before going further.

If you’ve done all 8 and still get the error, post your RPCS3.log to the RPCS3 Discord #help channel. The community there is active, and the developers monitor it. Include your GPU model, driver version, RPCS3 build number, and game region.

If LittleBigPlanet still crashes after clearing shader caches, you can also explore our advanced system and configuration troubleshooting guide for deeper debugging methods related to corrupted configurations and failed runtime environments.

FAQ