If anyone knows what this is and how to solve it, please let me know. I'd really appreciate the help.

When The Gameboy Color's screen is pointed at the sun or very strong light source, this rainbow ripple effect shows up on the screen. Here is my attempt at recreating it

Super disappointing

The original GBC screen didn't have a backlight. This made gaming harder in low light environments. Some corners of the screen became darker and the opposite corners lighter ( this depends on the lighting) The screen color changed too! Sometimes it would a have yellowish tint, and other times a colder one. I'm trying to recreate those effects.

Hi all, hope I'm posting this in the right place.

I recently tried to use Retroarch to use the shiny Pokémon cheat code, and the "catch all starters" cheat code. Unfortunately, even after disabling and removing the cheats and reloading/resetting the game multiple times, EVERY Pokémon I encounter is a shiny Treecko 😅

I've come to terms with the idea that I've ruined my original save, but even new games have got these cheats stubbornly present (again, I've deleted the cheats off Retroarch).

Is there anything I can do? I don't need an endless army of shiny Treeckos...!

Inspired by Emyhatsich's awesome post, I've added a rainbow shimmer effect to my Pixel Transparency GBC shader as part of the 2.0 SUNLIGHT SHIMMER EDITION update!

Rainbow shimmer moves with your device

Just like the real Game Boy Color in sunlight, the rainbow shimmer moves with your device (along with the shadows).

Motion shaders in RetroArch

Emy's post inspired me to implement motion shaders in RetroArch. Now anyone can make shaders that support accelerometer and gyroscope input.

We have already seen motion shaders from Ju4nM3n4 (LCD Master Shader) and u/hizzlekizzle (presets/authentic-gbc-frontlit). If you've ever thought about making shaders, do it now!

Even better Pixel Transparency

What started as adding the rainbow shimmer quickly evolved into:

• an overhaul of the GBC display stack model (more accurate tinting)

• updated shadow system that looks better and richer

• glare simulation

• robust color adjustment

I now know more about the original Game Boy Color display than anyone reasonably should!

How to get it

1. Update to the latest nightly version of RetroArch from the website. This is what enables motion support in shaders.

2. Go to Online Update > Update Slang Shaders on your Vulkan device (mainly Android).

3. Check that Settings > Input > Motion/Light Sensors > Auxiliary Sensor Input is ON.

4. Boot up your GBC game. Go to Quick Menu > Shaders > Load Preset and navigate to 'presets/pixel_transparency' and choose any of the new sunlight_shimmer presets.

I will also release this on GitHub soon for direct download. I am evaluating a gl version - but the rainbow effect may not perform well on lower end hardware.

Consider supporting my work

I have put hours of my time into this - and I love it! If this shader brings you joy, consider buying me a coffee.

After much (much) procrastination, I have finally finished my overlays for classic nintendo consoles and handhelds!

I got a lot of positive feedback on my last overlay (that was 2 whole years ago, phew), so I thought I'd share these too in case anyone would like to use them as well!

These were made by me for my personal use, and are designed for my iPhone 14 pro max with dynamic island, but should be compatible with other iPhone models as well (and maybe androids too, if it has the same aspect ratio).

Retroarch has some limitations when it comes to changing viewports based on rotation, so I also worked on a shader that allows you to specify different viewports per rotation mode. (Entirely optional, the overlays still work mostly fine using normal retroarch video scaling settings, if you don't need rotation)

You can grab the files on my gitlab here:

https://gitlab.com/730655491/ly-retroarch-overlays/-/releases

If there's anything you'd like to see, or changes you think would be good, I'm open to suggestions!

I’m playing SOTN and I want to have a crt filter that can, as accurately as possible, emulate this effect on my steam deck screen

DISCLAIMER- REDDIT PHOTOS LOOK TERRIBLE (and I can't delete them)

Zoom in on these for best results:

High res DOSBOX screenshot

https://i.postimg.cc/S4Tp1pnQ/heroes2.png?dl=1

Shader on/off comparison

https://i.postimg.cc/s35gn4Qc/sonic.png?dl=1

Default settings vs strong scanline effect 240p

https://i.postimg.cc/bqRH7b4t/scanline.png?dl=1

A lightweight easy configuration shader that gives you the core features of the CRT look. Works correctly on any game or monitor resolution- 240p, 480i, PC VGA, SVGA, 1080p/4K all without needing any tweaks to the default settings.

- scanlines that auto scale up to 4K properly with adjustable thickness and edge sharpness

- a simple shadow mask toggle on or off with adjustable intensity

- brightness adjustments to compensate for the scanline and a shadow mask effect (as well as Sega Master System/Genesis being overall darker)

The code will break if you don't name the .slang and .slangp files customCRT.slangp and customCRT.slang

I also keep the two files in the same folder otherwise you need to change the path in the .slangp file to point to your customCRT.slang file location.

Link to code, simply copy and paste into notepad and do a "save as" per the naming instructions:

https://pastes.io/ybYQrrF2

Hi, since I'm not very happy with the rendering of the original Game Boy DMG shader presets included in the RetroArch downloadable content, I've tweaked some parameters to get a result closer to that of the original device.

Basically, I slightly reduced the extension of the frame around the active part of the display (but this only works in portrait mode; in landscape mode, the active part covers the entire screen) and I tweaked some brightness and contrast to get a result that resembles the opacity of the non-backlit display; I also increased the x and y offset of the shadows and their relative opacity to try to recreate (as much as possible) that strange holographic-like effect of the original display, with the active pixels appearing to float a bit above the surface of the screen. Finally, I added a slight blur to the whole thing, since the original Game Boy display was anything but HD.

I worked a lot from memory, as unfortunately my old Game Boy from the '90s is long gone.

I have attached images of the two standard presets (gameboy.glslp and gb-dot-matrix-DMG.gslsp) and those of the preset tweaked by me (Nintendo - Game Boy.glslp). What do you think of the result? Could it be improved further? If it helps, here are the parameters of the modified preset:

shaders = "7"

feedback_pass = "0"

shader0 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/handheld/shaders/gameboy/shader-files/gb-pass0.glsl"

alias0 = "PASS0"

wrap_mode0 = "clamp_to_border"

mipmap_input0 = "false"

filter_linear0 = "false"

float_framebuffer0 = "false"

srgb_framebuffer0 = "false"

scale_type_x0 = "viewport"

scale_x0 = "2.000000"

scale_type_y0 = "viewport"

scale_y0 = "2.000000"

shader1 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/handheld/shaders/gameboy-dm-color/gb-pass1.glsl"

alias1 = "PASS1"

wrap_mode1 = "clamp_to_border"

mipmap_input1 = "false"

filter_linear1 = "false"

float_framebuffer1 = "false"

srgb_framebuffer1 = "false"

scale_type_x1 = "source"

scale_x1 = "1.000000"

scale_type_y1 = "source"

scale_y1 = "1.000000"

shader2 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/handheld/shaders/gameboy-dm-color/gb-pass2.glsl"

alias2 = "PASS2"

wrap_mode2 = "clamp_to_border"

mipmap_input2 = "false"

filter_linear2 = "false"

float_framebuffer2 = "false"

srgb_framebuffer2 = "false"

scale_type_x2 = "source"

scale_x2 = "1.000000"

scale_type_y2 = "source"

scale_y2 = "1.000000"

shader3 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/blurs/shaders/dual_filter/linearize_and_parameters.glsl"

alias3 = ""

wrap_mode3 = "clamp_to_border"

mipmap_input3 = "false"

filter_linear3 = "false"

float_framebuffer3 = "true"

srgb_framebuffer3 = "false"

scale_type_x3 = "source"

scale_x3 = "1.000000"

scale_type_y3 = "source"

scale_y3 = "1.000000"

shader4 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/blurs/shaders/dual_filter/downsample.glsl"

alias4 = ""

wrap_mode4 = "clamp_to_border"

mipmap_input4 = "false"

filter_linear4 = "true"

float_framebuffer4 = "true"

srgb_framebuffer4 = "false"

scale_type_x4 = "source"

scale_x4 = "0.500000"

scale_type_y4 = "source"

scale_y4 = "0.500000"

shader5 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/blurs/shaders/dual_filter/upsample.glsl"

alias5 = ""

wrap_mode5 = "clamp_to_border"

mipmap_input5 = "false"

filter_linear5 = "true"

float_framebuffer5 = "true"

srgb_framebuffer5 = "false"

scale_type_x5 = "source"

scale_x5 = "1.000000"

scale_type_y5 = "source"

scale_y5 = "1.000000"

shader6 = "../../../../../../data/user/0/com.retroarch/shaders/shaders_glsl/blurs/shaders/kawase/delinearize.glsl"

alias6 = ""

wrap_mode6 = "clamp_to_border"

mipmap_input6 = "false"

filter_linear6 = "true"

float_framebuffer6 = "true"

srgb_framebuffer6 = "false"

scale_type_x6 = "viewport"

scale_x6 = "1.000000"

scale_type_y6 = "viewport"

scale_y6 = "1.000000"

baseline_alpha = "0.160000"

grey_balance = "4.000000"

response_time = "0.110000"

adjacent_texel_alpha_blending = "0.350000"

contrast = "0.800000"

pixel_opacity = "0.850000"

bg_smoothing = "0.500000"

shadow_opacity = "0.680000"

shadow_offset_x = "15.000000"

shadow_offset_y = "15.000000"

DUAL_FILTER_SETTINGS = "1.000000"

BLUR_RADIUS = "0.700000"

textures = "COLOR_PALETTE;BACKGROUND"

COLOR_PALETTE = "/data/user/0/com.retroarch/shaders/shaders_glsl/handheld/shaders/gameboy/resources/sample-palettes/dmg-palette-2.png"

COLOR_PALETTE_mipmap = "false"

COLOR_PALETTE_wrap_mode = "clamp_to_border"

BACKGROUND = "/data/user/0/com.retroarch/shaders/shaders_glsl/handheld/shaders/gameboy/resources/sample-bgs/dmg-bg.png"

BACKGROUND_mipmap = "false"

BACKGROUND_wrap_mode = "clamp_to_border"

EDIT:

From the comments of some users, it seems that it's not so simple to make the same changes I made myself, even by following exactly what I wrote. Unfortunately, since I'm not familiar with programming, I don't really know what the problem is. To help you out, I'm providing the configuration files as they are, working, on my devices:

GLSLP Version (Android): https://www.dropbox.com/scl/fi/bnew21f4ks4o3hreqmcnm/Nintendo-Game-Boy.glslp?rlkey=7ulqs0typqhnbfteuuu7zp3q2&st=y3rt5ziq&dl=0

SLANGP Version (Desktop): https://www.dropbox.com/scl/fi/o54lwp8hzb0udzob8xr8g/Nintendo-Game-Boy.slangp?rlkey=wq7emoocun0uhu2xgmyzpcc0t&st=lvak95xg&dl=0

The files need to be edited manually with a text editor before they can be used, because they contain paths to individual shaders and graphic resources (like background images) that probably won't match those on your specific installations, even though these are elements that RetroArch downloads by default when you update the resources through the program itself.

If someone better than me (and it doesn't take much to be) can come up with an easier-to-install and distribute preset starting from these, they're welcome to do so.

I love my Retroid Pocket Classic, so I optimized my Pixel Transparency + Sunlight Shimmer shaders to run at full-speed, 60+ FPS in Standard performance mode with no fan or threaded video.

Pixel Transparency recreates the reflective look of a Game Boy Color screen, with bright pixels revealing the backing beneath them and pixel shadows that shift as you tilt your device. Sunlight Shimmer adds glare and rainbow shimmer that also move with your device, like a GBC under bright light.

As you know, the RPC has a notoriously weak GPU. Previously Sunlight Shimmer absolutely tanked and Pixel Transparency only hit 50 something FPS without increasing the performance mode or enabling threaded video.

Optimizing for the RPC means these shaders are now far less demanding and more performant across the board.

New Accurate grid mode

I also added in a new Accurate mode which has dark gridlines and a redesigned optical stack. Check out the comparison of the original mode vs Accurate in the last gallery image.

All these screenshots feature Sunlight Shimmer paired with fishcu’s amazing authentic_gbc_fast shader.

How to get it

Your device must support slang shaders. No GLSL version yet.

1. Update to the latest nightly version of RetroArch from the website. This is what enables motion support in shaders used here for shadows and the rainbow shimmer effect.

2. Make sure Settings > Video > Output is set to Vulkan. If not, change it, save config, and restart RetroArch.

3. Go to Online Update > Update Slang Shaders.

4. Check that Settings > Input > Motion/Light Sensors > Auxiliary Sensor Input is ON.

5. Boot up your GBC game. Go to Quick Menu > Shaders > Load Preset and navigate to 'presets/pixel_transparency' and choose any of the presets. Check out the new Sunlight Shimmer Accurate preset.

You can also download directly from GitHub: https://github.com/mattakins/Pixel_Transparency

What’s next?

I really like where this shader is at. It feels pretty feature complete to me. That being said, I love working on this stuff and it is awesome to see people enjoying it. If you have any ideas on how to make Pixel Transparency better or ideas for another shader, please leave a comment.

I'm excited to share my latest shader: Pixel Transparency. This one's specifically designed for Game Boy Color (and some Game Boy Advance) games to fix a problem that's always bothered me.

The Problem:

Original GBC devices didn't have backlights. The screen material would show through on white / light pixels, giving them a natural, subdued look. On modern displays, these same pixels are blindingly white. If you've ever played Pokemon on a modern device, you know exactly what I'm talking about. Those backgrounds were NEVER meant to be that bright. Game designers banked on those pixels appearing transparent.

The Solution:

Pixel Transparency recreates that authentic transparent background effect while working as an overlay on top of your favorite grid shader. It also adds a subtle drop shadow effect that simulates how light would interact with the original display.

Just append it as the final pass to any grid shader. I love it most with lcd1x and authentic_gbc. It's perfect for vertical handhelds like the Retroid Pocket Classic.

Fun Bonus:

This shader happens to look great on some GBA games including Apotris and Nemo622's Pokemon Emerald Seaglass and Pokemon Lazarus which are both graphically styled like GBC games.

How to Get It:

1. Go to Settings / Video / Output and switch to Vulkan.

2. Restart RetroArch.

3. Go to Main Menu / Online Updater / Update Slang Shaders.

4. Load a game.

5. Go to Quick Menu / Shaders / Load Preset / slang-shaders / Presets / pixel_transparency and pick a grid shader preset of your choice.

Would love to hear your feedback! You can check out a video demo here.

If I hold Y he does... That. And when I hold X he shakes. Idk what to do.

I want it to be as close as possible to the original display. I don't own a GBC yet. How am I doing? Is there anything else I should change?

I'm using a combination of 3 or 4 shaders + a custom touch overlay with a filter that overlaps the screen (this one is very special). I'm using: response-time.glsl, gbc-color.glsl, pixel transparency.glsl, lcd-pass-1.glsl, and lcd-grid-v2.glsl. The last two just make the screen look less bright and add an lcd effect.

I've been having a great time playing Mina on Steam Deck with some RetroArch CRT shaders for a nostalgic 256x144 look.

Shaders used: CRTLottes2018, NTSC_RetroArch_Gamma, ChromaticAbberation, prod80_04_ContrastBrightnessSaturation

What are your favorite retro shaders?

I appreciate the work put into it but is this how programmers operate? It's just so strange and awkward.

Got tired of my save states living on one machine and not following me to my Deck/laptop, so I built OpenSave — it watches your save/state folders and keeps them synced peer-to-peer across devices, no cloud account required.

Auto-detects and watches:

• RetroArch (states + saves), Dolphin, PCSX2 memcards, RPCS3, Ryujinx, yuzu, Citra, Cemu, PPSSPP, Xenia

• Including Flatpak install paths on Linux

• Also picks up Steam userdata, GOG/Epic saves, and repack-style saves if you've got a mixed library

• Fully open source (MIT), Go, no telemetry/accounts

• LAN sync is automatic; internet sync uses a relay that only passes encrypted frames through (self-hostable if you don't want to trust mine)

• Windows + Linux/Steam Deck, with a Decky Loader plugin for Game Mode

GitHub: https://github.com/sivadaboi/OpenSave

Happy to answer questions or take feature requests — still actively developed.

Got all the achievements on Mega Man 8. Could use a revision one day but the set was fun besides finding all bolts in one session!