Rendering Pipeline

Rendering Pipeline in Godot 4.3+

Project-level rendering decisions: which renderer runs where, how the lighting is built for it, how edges are smoothed, what resolution 3D renders at, and how to measure the result. All examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, then C#.

This skill picks the strategy; 3d-essentials holds the per-node recipes (materials, light properties, GI setup, fog, decals).

Related skills: 3d-essentials for materials, lights, environment and GI node setup, 2d-essentials for 2D lights and shadows, shader-basics for post-processing, compositor effects and the Shader Baker, godot-optimization for profiling CPU/GPU bottlenecks, web-export for the Compatibility-only browser target.

1. Pick the Renderer First

The renderer decides which lighting features exist at all, so choose it before building the look.

Set Project Settings → Rendering → Renderer → Rendering Method. Platform overrides already exist: rendering/renderer/rendering_method.mobile defaults to mobile and rendering_method.web to gl_compatibility, so one project can run Forward+ on desktop and Mobile on phones — but then test the look on both, because effects silently disappear on the lighter renderer.

A settings menu must hide options the running renderer cannot honor. The later sections use this helper:

gdscriptCopy code
func is_forward_plus() -> bool:
    # Godot 4.4+: prefer RenderingServer.get_current_rendering_method(), which also sees
    # the --rendering-method CLI flag and the automatic fallback on unsupported hardware.
    return ProjectSettings.get_setting_with_override("rendering/renderer/rendering_method") == "forward_plus"

csharpCopy code
public static bool IsForwardPlus()
{
    // Godot 4.4+: prefer RenderingServer.GetCurrentRenderingMethod(), which also sees
    // the --rendering-method CLI flag and the automatic fallback on unsupported hardware.
    return ProjectSettings.GetSettingWithOverride("rendering/renderer/rendering_method").AsString() == "forward_plus";
}

Short feature table: see the renderer comparison in 3d-essentials (references/renderer-comparison.md).

2. Lighting Strategy

Decide where light comes from before placing lights. Baked light is nearly free at runtime on every renderer; real-time GI is Forward+ only.

Light budgets

Rules that hold everywhere:

• Shadows are the expensive part, not lights. Keep one shadowed DirectionalLight3D; turn shadow_enabled off on fill lights and small props.
• Bake what doesn't move. Set static lights' light_bake_mode to Static so the lightmap carries them and they cost nothing at runtime. Baking needs a Forward+ or Mobile capable editor; the baked result plays on all three renderers.
• Fade distant lights with distance_fade_enabled instead of leaving dozens active.

Light and GI node setup: 3d-essentials (Sections 3 and 5).

3. Anti-Aliasing

The project settings (rendering/anti_aliasing/quality/*) are read once at startup. To change AA from a settings menu, set the root viewport:

gdscriptCopy code
func apply_antialiasing(msaa: Viewport.MSAA, use_fxaa: bool, use_taa: bool) -> void:
    var vp := get_viewport()
    vp.msaa_3d = msaa
    vp.screen_space_aa = Viewport.SCREEN_SPACE_AA_FXAA if use_fxaa else Viewport.SCREEN_SPACE_AA_DISABLED
    vp.use_taa = use_taa and is_forward_plus()

csharpCopy code
public void ApplyAntialiasing(Viewport.Msaa msaa, bool useFxaa, bool useTaa)
{
    Viewport vp = GetViewport();
    vp.Msaa3D = msaa;
    vp.ScreenSpaceAA = useFxaa ? Viewport.ScreenSpaceAAEnum.Fxaa : Viewport.ScreenSpaceAAEnum.Disabled;
    vp.UseTaa = useTaa && IsForwardPlus();
}

Setting an unsupported mode does not crash; Godot ignores it and logs a warning (an editor error on 4.3–4.5). Gate the options in the UI instead. 2D has its own msaa_2d, which smooths 2D geometry edges such as lines and polygons.

4. 3D Resolution Scaling

Render 3D below native resolution and upscale it — the biggest single GPU saving on fill-rate-bound scenes. 2D and UI stay at native resolution.

Offer presets rather than a raw slider. These are AMD's FSR 1 scales, which work as well with FSR 2: Ultra Quality 0.77, Quality 0.67, Balanced 0.59, Performance 0.5.

gdscriptCopy code
const FSR_PRESETS := {"ultra_quality": 0.77, "quality": 0.67, "balanced": 0.59, "performance": 0.5}


func apply_upscaling(preset: String) -> void:
    var vp := get_viewport()
    if preset == "native":
        vp.scaling_3d_mode = Viewport.SCALING_3D_MODE_BILINEAR
        vp.scaling_3d_scale = 1.0
        return
    vp.scaling_3d_mode = Viewport.SCALING_3D_MODE_FSR2 if is_forward_plus() else Viewport.SCALING_3D_MODE_BILINEAR
    vp.scaling_3d_scale = FSR_PRESETS.get(preset, 1.0)

csharpCopy code
private static readonly System.Collections.Generic.Dictionary<string, float> FsrPresets = new()
{
    { "ultra_quality", 0.77f }, { "quality", 0.67f }, { "balanced", 0.59f }, { "performance", 0.5f },
};

public void ApplyUpscaling(string preset)
{
    Viewport vp = GetViewport();
    if (preset == "native")
    {
        vp.Scaling3DMode = Viewport.Scaling3DModeEnum.Bilinear;
        vp.Scaling3DScale = 1.0f;
        return;
    }
    vp.Scaling3DMode = IsForwardPlus() ? Viewport.Scaling3DModeEnum.Fsr2 : Viewport.Scaling3DModeEnum.Bilinear;
    vp.Scaling3DScale = FsrPresets.GetValueOrDefault(preset, 1.0f);
}

Lower scales blur textures; on Forward+ and Mobile, Godot lowers the mipmap bias automatically by log2(scale) to compensate (plus -0.5 with TAA).

5. SubViewports and Render Targets

Each active SubViewport is another full render. Set render_target_update_mode: UPDATE_WHEN_VISIBLE (live views), UPDATE_ONCE (snapshots), UPDATE_DISABLED (pause), UPDATE_ALWAYS.

See references/subviewports.md for UI display, per-viewport settings, and icon capture.

6. Shader Compilation Stutter

The first time a material, light combination, or effect is drawn, the GPU pipeline is compiled, which can hitch a frame.

• Godot 4.4+ compiles pipelines in the background with ubershaders on Forward+ and Mobile, which removes most of this hitching. Projects on 4.3 benefit from upgrading.
• The pipeline cache (rendering/rendering_device/pipeline_cache/enable, on by default) makes the second launch faster than the first.
• The Shader Baker (Godot 4.5+, export preset option) shortens the first launch on D3D12 and Metal — see shader-basics and export-pipeline.
• On Compatibility, and for effects that still hitch, show each material once behind a loading screen (spawn the effect off-camera or at zero scale for a frame).

7. Measuring

Read rendering stats from Performance and switch Viewport.debug_draw to see where the cost is.

gdscriptCopy code
func _process(_delta: float) -> void:
    $Stats.text = "draw calls %d | primitives %d | VRAM %.0f MB" % [
        Performance.get_monitor(Performance.RENDER_TOTAL_DRAW_CALLS_IN_FRAME),
        Performance.get_monitor(Performance.RENDER_TOTAL_PRIMITIVES_IN_FRAME),
        Performance.get_monitor(Performance.RENDER_VIDEO_MEM_USED) / 1048576.0,
    ]


func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("debug_overdraw"):
        var vp := get_viewport()
        vp.debug_draw = Viewport.DEBUG_DRAW_DISABLED if vp.debug_draw == Viewport.DEBUG_DRAW_OVERDRAW else Viewport.DEBUG_DRAW_OVERDRAW

csharpCopy code
public override void _Process(double delta)
{
    GetNode<Label>("Stats").Text = string.Format("draw calls {0} | primitives {1} | VRAM {2:F0} MB",
        Performance.GetMonitor(Performance.Monitor.RenderTotalDrawCallsInFrame),
        Performance.GetMonitor(Performance.Monitor.RenderTotalPrimitivesInFrame),
        Performance.GetMonitor(Performance.Monitor.RenderVideoMemUsed) / 1048576.0);
}

public override void _UnhandledInput(InputEvent @event)
{
    if (@event.IsActionPressed("debug_overdraw"))
    {
        Viewport vp = GetViewport();
        vp.DebugDraw = vp.DebugDraw == Viewport.DebugDrawEnum.Overdraw ? Viewport.DebugDrawEnum.Disabled : Viewport.DebugDrawEnum.Overdraw;
    }
}

Useful debug_draw modes: OVERDRAW (transparency and particle cost), UNSHADED (is it lighting or geometry?), LIGHTING, WIREFRAME (call RenderingServer.set_debug_generate_wireframes(true) before the meshes load). The editor's Debugger → Visual Profiler splits GPU time per pass. Profiling method: godot-optimization.

8. Graphics Settings Menu

Players expect presets (Low / Medium / High / Ultra) plus individual toggles, saved between sessions. Apply runtime settings to the root viewport, environment toggles to the active Environment, and store the choice in a ConfigFile under user://.

Full preset table, apply code, and persistence in GDScript and C#: references/graphics-settings.md.

9. Common Pitfalls

10. Checklist

• Renderer chosen per target platform; .mobile / .web overrides reviewed
• The look is checked on the lightest renderer that ships
• Lighting plan written down: what is baked, what is real-time, which lights cast shadows
• Light counts within the renderer's budget (512 clustered / 8+8 per mesh on Mobile and Compatibility)
• AA method matches the renderer; menu hides unsupported options
• 3D resolution scaling offered as presets (FSR 2 on Forward+, bilinear elsewhere)
• Every SubViewport has a deliberate update mode, size, and its own AA settings
• Draw calls, primitives, and VRAM checked with Performance monitors on target hardware
• Graphics settings saved to user:// and re-applied on startup