Below are descriptions of both to help you identify which you need. 1. Stylized "Paper" Effects in Citra Emulator
If you want your Citra games to look like a paper drawing or a stylized animation, you are likely looking for Post-Processing Shaders.
Cel Shading: This is the most common technique used to achieve a "hand-drawn" or paper-like look. It works by thresholding colors in the HSV color space to replace smooth gradients with flat colors and bold outlines.
Implementation: In Citra, these effects are usually applied via a Post-Processing Shader Pack. You can drop .glsl shader files into the /citra-emu/shaders folder and select them in the Graphics settings.
Paper Mario Example: Specific optimizations for games like Paper Mario: Sticker Star or Paper Jam often focus on Shader Caching to prevent stuttering while maintaining the game's unique paper aesthetic. 2. "Paper Shaders" (Design Tool)
There is also a modern design library called Paper Shaders (part of Paper.design) that provides high-quality GPU-accelerated visual effects for websites and UI design.
Aesthetic Filters: It includes specialized shaders like paper texture, image dithering, and halftone dots.
Usage: These are often used as React components or vanilla JavaScript functions to create organic, paper-like backgrounds and transitions for web projects.
Design Context: Users often compare it to tools like Figma but with built-in shader effects. 3. Realistic Paper Material (3D Rendering)
If you are trying to generate a shader that looks like paper for a 3D model (e.g., in Arnold or Maya): Paper.design - It's like Figma, with Shaders
The Citra shader is a fundamental component of the Citra emulator, the premier software for playing Nintendo 3DS games on PC and mobile devices. In the context of emulation, shaders are specialized programs that run on your graphics card (GPU) to determine how pixels and vertices are drawn. For Citra users, understanding how shaders work—specifically the shader cache and custom shader effects—is the key to achieving a smooth, high-definition gaming experience that often surpasses the original handheld hardware. citra shader
One of the most common hurdles for new Citra users is "shader stutter." When a game requests a new visual effect or enters a new area, the emulator must compile the necessary shader instructions for your specific GPU. This process takes a fraction of a second, but it creates a noticeable hitch in gameplay. To solve this, Citra utilizes a shader cache. As you play, the emulator stores compiled shaders on your disk. The next time you encounter that specific effect, Citra loads it instantly from the cache, resulting in fluid movement. Many enthusiasts share pre-compiled shader caches for popular titles like Pokemon or The Legend of Zelda, though these must often be generated on your own hardware to ensure compatibility with your specific drivers.
Beyond basic performance, Citra supports post-processing shaders that can radically transform a game's appearance. While the original 3DS had a native resolution of only 400x240 pixels, Citra’s shader engine allows for internal resolution scaling up to 10x. By applying texture filtering and anti-aliasing shaders, jagged edges are smoothed out and flat textures gain new depth. Advanced users often implement custom "Reshade" profiles or internal Citra post-processing filters like FXAA or Anime4K. These shaders can mimic the look of a high-end CRT monitor, enhance colors to look more vibrant on modern OLED screens, or even sharpen lines to give games a hand-drawn, cell-shaded aesthetic.
Optimizing your Citra shader settings depends heavily on your hardware. For those on lower-end machines or Android devices, enabling "Hardware Shader" support in the graphics settings is mandatory to offload work from the CPU. On the other hand, users with powerful NVIDIA or AMD cards can experiment with "Separate Shader Subgraph" settings to further reduce compilation lag. Whether you are looking to preserve the nostalgic look of the original 3DS or push the graphics into the realm of modern consoles, mastering the Citra shader system is the most effective way to customize your emulation journey.
Can I help you with specific Citra settings for a particular game or hardware setup?
The "Preparing Shaders" feature in (and its successors like ) is a critical background process that compiles graphical data from 3DS games into a format your computer's GPU can understand. Without this feature, players would experience constant "micro-stutters" or freezes every time a new visual effect or object appears on screen. Core Functionality Compilation
: When a game encounters a new shader, Citra must recompile it for your specific graphics API— OpenGL, Vulkan, or DirectX Persistence : Once a shader is compiled, it is saved to a Disk Shader Cache
. This allows Citra to load the pre-compiled data the next time you launch the game, ensuring smooth gameplay from the start. Performance Impact
: While building the cache for the first time can cause temporary frame drops, a complete cache allows games to run at a consistent frame rate, even at 4K resolutions Key Feature Settings
In the context of the Citra 3DS emulator, "shaders" typically refer to two distinct things: the internal rendering programs used to translate 3DS graphics to your PC or Android hardware, and post-processing shaders used to change the visual aesthetic (like adding scanlines or color correction). 1. Internal Hardware Shaders & Performance
Citra uses Hardware Shaders to offload graphical tasks from your CPU to your GPU, which is essential for achieving full speed in demanding titles like Pokémon Ultra Sun/Moon. Below are descriptions of both to help you
Shader Compilation Stutter: Emulators must translate 3DS shader instructions into a format your GPU understands (OpenGL or Vulkan). When a game encounters a new visual effect, it may pause briefly to compile this shader, causing "micro-stuttering".
Disk Shader Cache: This feature saves compiled shaders to your storage so they don't need to be rebuilt every time you play. You can enable this under Emulation > Configure > Graphics > Advanced.
Asynchronous Shader Building: Supported in many modern forks (like Citra MMJ and Azahar), this allows shaders to compile in the background. While it eliminates stutter, it may cause temporary "flickering" or missing objects until the shader is ready. 2. Post-Processing Shaders (Visual Filters)
These are optional scripts (typically in .glsl format) that apply visual effects to the final image. Citra MMJ stuttering on some games : r/EmulationOnAndroid
// Citra Shader - Nintendo 3DS Emulator Visual Style
// Compatible with ReShade 4.9+
// Simulates the look of Citra rendering with LCD-like artifacts
// Uniforms
uniform float uVibrance <
string label = "Vibrance";
string description = "Increases color saturation non-linearly.";
float minimum = 0.0;
float maximum = 1.0;
float default = 0.35;
>;
uniform float uDesat <
string label = "Desaturation";
string description = "Global desaturation to mimic 3DS screen limits.";
float minimum = 0.0;
float maximum = 1.0;
float default = 0.15;
>;
uniform float uScreenDoor <
string label = "Screen Door Effect";
string description = "Intensity of the grid pattern (LCD pixel separation).";
float minimum = 0.0;
float maximum = 1.0;
float default = 0.2;
>;
uniform float uGamma <
string label = "Gamma";
string description = "Gamma correction for 3DS-like contrast.";
float minimum = 0.8;
float maximum = 2.2;
float default = 1.2;
>;
uniform bool uSubpixelMode <
string label = "Subpixel Simulation";
string description = "Emulates RGB stripe subpixel layout (more authentic).";
float default = true;
>;
// Helper: RGB to luminance
float luminance(vec3 color)
return dot(color, vec3(0.299, 0.587, 0.114));
// Helper: Vibrance filter (boosts less-saturated colors more)
vec3 vibrance(vec3 color, float amount)
float luma = luminance(color);
float maxChannel = max(color.r, max(color.g, color.b));
float minChannel = min(color.r, min(color.g, color.b));
float saturation = maxChannel - minChannel;
vec3 adjusted = mix(vec3(luma), color, 1.0 + amount * (1.0 - saturation));
return adjusted;
// Helper: Subpixel simulation (RGB stripe pattern)
vec3 subpixelGrid(vec2 texCoord, vec3 color, float intensity)
// Determine subpixel column offset (0=red, 1=green, 2=blue)
float pixelX = texCoord.x * float(getResolution().x);
int subpixelIndex = int(mod(pixelX, 3.0));
vec3 result = color;
if (subpixelIndex == 0)
result.g *= (1.0 - intensity * 0.5);
result.b *= (1.0 - intensity * 0.5);
else if (subpixelIndex == 1)
result.r *= (1.0 - intensity * 0.5);
result.b *= (1.0 - intensity * 0.5);
else
result.r *= (1.0 - intensity * 0.5);
result.g *= (1.0 - intensity * 0.5);
return result;
// Main fragment shader
float4 mainImage(float4 fragColor, float2 fragCoord, float2 texCoord)
// Get original color
vec3 color = tex2D(ReShade::BackBufferTex, texCoord).rgb;
// Gamma correction (inverse first, then reapply)
color = pow(color, vec3(1.0 / uGamma));
// Vibrance (boost weak colors)
color = vibrance(color, uVibrance);
// Desaturation (lower global saturation)
float luma = luminance(color);
color = mix(color, vec3(luma), uDesat);
// Screen-door effect (alternating grid)
vec2 screenSize = getResolution().xy;
vec2 gridCoord = fragCoord;
float gridPattern = (mod(gridCoord.x, 2.0) * mod(gridCoord.y, 2.0));
gridPattern = abs(gridPattern - 0.5) * 2.0; // 0 or 1 pattern
color *= (1.0 - uScreenDoor * 0.3 * gridPattern);
// Optional subpixel simulation
if (uSubpixelMode)
color = subpixelGrid(texCoord, color, 0.2);
// Slight scanline effect (horizontal lines)
float scanline = sin(texCoord.y * screenSize.y * 3.14159 * 2.0) * 0.05;
color += scanline;
// Dithering (optional, low intensity)
float noise = fract(sin(dot(fragCoord, vec2(12.9898, 78.233))) * 43758.5453);
color += (noise - 0.5) * 0.02;
// Final gamma output
color = pow(color, vec3(uGamma));
return float4(color, 1.0);
| Setting | Shader Behavior | Effect | |---------|----------------|--------| | Accurate Multiplication (On) | Emulates PICA200’s precise, slightly non‑standard multiplication order | Fixes artifacts in games like Luigi’s Mansion: Dark Moon, but ~10% slower | | Shader JIT (On) | Recompiles shaders to native GPU code | Massive speedup, essential for real-time | | Resolution Scaling (>1x) | Shader must account for extra pixels, texture sampling adjusted | Can break shader logic if not handled carefully (e.g., UI bleed) |
Not every shader works for every game. Here is a curated optimization list.
| Game Title | Best Shader | Reasoning | | :--- | :--- | :--- | | Pokémon Ultra Sun/Moon | FidelityFX CAS | The games have a soft watercolor aesthetic. CAS restores texture detail without breaking the art style. | | Super Mario 3D Land | xBRZ (Level 2) | The game uses simple textures. xBRZ prevents the "blocky" look of the flag poles and coins. | | The Legend of Zelda: OoT 3D | Anime4K (Upscale) | Removes the muddy textures of the 3DS port and sharpens Link’s tunic details. | | Fire Emblem: Awakening | Darken + Selective Bloom | The battle sprites benefit from higher contrast; lower the bloom to see the battlefield map clearly. | | Monster Hunter 4 Ultimate | No Shader (Use 4x Res) + FXAA | MH4U has dynamic depth of field. Most shaders break the UI compass. Stick to internal upscaling only. |
vec2 texel = 1.0 / tex_size;
vec3 sharp = color.rgb * 5.0;
sharp -= texture(color_texture, uv + vec2(-texel.x, -texel.y)).rgb;
sharp -= texture(color_texture, uv + vec2( texel.x, -texel.y)).rgb;
sharp -= texture(color_texture, uv + vec2(-texel.x, texel.y)).rgb;
sharp -= texture(color_texture, uv + vec2( texel.x, texel.y)).rgb;
color.rgb += (color.rgb - sharp / 4.0) * 0.5;
xBRZ (Scale by Rules) is a pixel-art scaling algorithm.
Designed for upscaling animated films, Anime4K works wonders on cel-shaded 3DS games.
Citra.fx (or similar) in your ReShade Shaders folder.Vibrance = 0.35, Desaturation = 0.15, Screen Door = 0.2, Gamma = 1.2.This shader works particularly well for 3DS games emulated in Citra, giving them that characteristic soft, slightly gritty LCD look. Sharpening (basic) vec2 texel = 1
Level Up Your Visuals: A Guide to Citra Shaders If you’ve been using Citra to revisit 3DS classics, you know the jump to HD resolution is already a game-changer. But to truly push the aesthetic—or to fix that annoying "shader stutter"—you need to dive into the world of shaders. 1. Performance Shaders: Solving the Stutter
The most critical type of shader in Citra isn't for looks; it’s for performance. Shader compilation often causes micro-stutters when a game loads a new effect for the first time.
Hardware Shader Updates: Modern versions of Citra (and its successors like Lime3DS) use GPU-based shader emulation to significantly boost speed in demanding titles like Pokémon Ultra Sun.
Vulkan Support: Enabling the Vulkan graphics API allows for better shader cache handling, which reduces those "one-time" freezes during gameplay.
Asynchronous Shaders: While still being refined in various forks, this tech allows shaders to compile in the background, keeping your frame rate smooth even when new assets load. 2. Post-Processing Shaders: The "Pro" Look
Post-processing shaders apply visual filters over the entire screen after the game renders. These can make a 3DS game look like a modern indie title.
LCD & Scanline Shaders: For a nostalgic feel, community-made shaders can simulate the original 3DS screen's pixel grid or add scanlines for a CRT vibe.
Smoothing & Upscaling: Shaders like FXAA or xBRZ help smooth out jagged edges on sprites and text, which is especially helpful when playing 2D games at high resolutions.
Color & Lighting: Using tools like ReShade with Citra can add depth-of-field, ambient occlusion, or vibrant color correction. 3. How to Install and Use Shaders Ready to experiment? Here is how to get started:
Here’s a Citra (3DS emulator) shader preparation guide — focused on post-processing effects (like contrast, sharpening, color grading, scanlines, LCD grid, etc.) that you can apply in Citra’s post-processing shader system.
Citra shaders generally fall into three categories: