Fix: Godot Game Looks Different in the Compatibility Renderer (or on Some Players’ PCs)

A scene that looks right in Forward+ can come out flat, dark or oddly lit in Compatibility. That matters more than it used to: web builds always use Compatibility, many developers choose it for low-end hardware, and players whose GPUs lack Vulkan support may be running it without you knowing.

What Compatibility does not do

Compatibility trades features for reach. Compared with Forward+, the effects most likely to change how your scene looks are:

• Global illumination: no SDFGI or VoxelGI. Bake a LightmapGI instead, which Compatibility supports.
• Screen-space effects: no SSAO, SSIL or SSR.
• Volumetric fog is not available; regular depth and height fog are.
• Glow and tonemapping behave differently, and glow is missing entirely in older 4.x releases.
• Light limits: a mesh is lit by a limited number of lights (8 by default) and the scene has a cap on renderable lights. Extra lights simply do not affect the object.

Godot's documentation has a feature comparison table between renderers; check it for your version, since Compatibility gains features with each release.

Why some players see it without choosing it

• Web exports always use Compatibility.
• Automatic fallback: recent Godot versions can fall back to Compatibility when a PC cannot run Vulkan (older GPUs, outdated drivers, some virtual machines), controlled by a fallback setting under Rendering Device in Project Settings. The game launches instead of showing a Vulkan error, but it renders with a different renderer than you tested.
• Per-platform overrides: Project Settings > Rendering > Renderer > Rendering Method has .mobile and .web overrides that may select Compatibility.

Detect the renderer at runtime

func _ready() -> void:
    var method := RenderingServer.get_current_rendering_method()
    print("Renderer: ", method, " on ", RenderingServer.get_video_adapter_name())
    if method == "gl_compatibility":
        _apply_compatibility_look()

func _apply_compatibility_look() -> void:
    var env: Environment = $WorldEnvironment.environment
    env.ambient_light_energy = 1.4      # make up for missing GI
    env.tonemap_exposure = 1.1

Values like these are starting points; tune them by eye in Compatibility.

Test it without changing the project

Run the game with the Compatibility renderer from the command line, or from Debug > Customize Run Instances arguments in the editor:

godot --path . --rendering-method gl_compatibility

Walk through each level and compare screenshots with Forward+. Darker interiors (missing GI), objects lit by too many lights (light limit) and flat reflective surfaces (no SSR) are the usual finds.

Adapting the scene

• Bake lightmaps for static lighting so both renderers get indirect light.
• Use ReflectionProbe nodes rather than relying on SSR.
• Split large meshes, or reduce overlapping lights, where the per-object light limit cuts lights.
• If your art direction needs Forward+ features, make that a requirement: disable the automatic fallback and show a clear message on unsupported hardware instead of a broken-looking game.

Knowing which renderer players run

“The game is too dark” from one player and not another is often a renderer difference. Bugnet's Godot SDK is a single GDScript autoload that watches the engine log and files errors, script errors and fatal errors automatically with recent log lines, a screenshot, the platform, OS, hardware and game version, and players can report everything else through Bugnet.show_widget(). You can add the rendering method from RenderingServer to report metadata, so visual complaints arrive already split by renderer and GPU.

Related problems

• How to Fix “Your video card drivers seem not to support the required Vulkan version” in Godot
• How to Fix a Godot Web Export That Won't Load
• Fix: Screen Flickering Tearing Godot

Frequently asked questions

What features does Godot’s Compatibility renderer lack?

Compared with Forward+, it has no SDFGI, VoxelGI, SSAO, SSIL, SSR or volumetric fog, and limits how many lights affect each object. Glow and tonemapping also differ.

How do I check which renderer my Godot game is using?

Call RenderingServer.get_current_rendering_method(). It returns forward_plus, mobile or gl_compatibility.

Why does my Godot game use Compatibility on some PCs?

Web exports always use it, per-platform settings may select it, and recent Godot versions fall back to it automatically when Vulkan is not available.

Run every level once with --rendering-method gl_compatibility before you ship a web build.