Agent skill

Scenario Godot Rendering Lighting

by scenario-labs in scenario-labs/skills

A skill your agent uses when lighting or rendering a Godot 4.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps…

MITAuto-check passedGame Development

Install Scenario Godot Rendering Lighting

skills CLI
$ npx skills add scenario-labs/skills --skill scenario-godot-rendering-lighting -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install scenario-labs/skills scenario-godot-rendering-lighting --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/scenario-labs/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/game-engines/godot/scenario-godot-rendering-lighting .claude/skills/scenario-godot-rendering-lighting && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
scenario-godot-rendering-lighting
GitHub stars
946
Token cost
~4.9k tokens
SKILL.md length
2,093 words
Files
15 (incl. scripts, references)
Skills in repo
146
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when lighting or rendering a Godot 4.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps…

  • Works in 8 steps: Use lightmaps for static scenes.… → Calibrate on a lookdev scene before… → Pick the tonemapper by look, then retune… → …
  • Rendering a Godot 4.7 3D scene: pick a renderer (Forward+
  • SKILL.md covers Stance (the expert delta), Establish first, Workflow and Expert checklist (state these…, plus 6 more sections
  • Runs Python scripts from its folder; calls npx

What it does

Scenario Godot Rendering Lighting is an agent skill from scenario-labs/skills. Use when lighting or rendering a Godot 4.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps without a mouse, tune WorldEnvironment, tonemapper (AgX, ACES, Filmic), glow, fog, volumetric fog and god rays, shadows and shadow acne, quality presets for PC and phones, Compositor post effects, or when 'my scene looks flat', 'too dark indoors', 'light leaks', 'lightmap is black', 'looks different on mobile'.

Its SKILL.md is about 4.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 19 other files, including scripts and reference files (for example `references/critique.md`, `references/expert-notes.md` and `references/gui-paths.md`).

It sits in Game Development, covering Game development. It works with Godot. The repository describes itself as: Get production-ready images, video, audio, and 3D from any AI agent: skills that pick the right model, price before spending, and keep characters and brands consistent through… The licence is MIT.

When your agent uses it

  • Rendering a Godot 4.7 3D scene: pick a renderer (Forward+
  • Choose GI (SDFGI
  • Reflection probes)
  • Bake lightmaps without a mouse

Example prompts

  • “my scene looks flat”
  • “too dark indoors”
  • “light leaks”
  • “/scenario-godot-rendering-lighting”

Requirements

  • Python 3
  • Node.js

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Use lightmaps for static scenes. SeasonalAsh measured on an RTX 4060 that SDFGI roughly halves fps, VoxelGI runs at 60 to 80 fps, and…
  2. Calibrate on a lookdev scene before lighting the level. Brackeys uses guide spheres (dark, white, mirror) and Display > Lighting (Brackeys…
  3. Pick the tonemapper by look, then retune exposure. Brackeys and Wild Ox use AgX; SeasonalAsh and LegionGames use ACES. Measured: AgX gives…
  4. Make emission readable on two levels. Glow makes an emitter look bright; a real light (or baked GI) makes it light the scene (Brackeys…
  5. Never use SDFGI and VoxelGI together, and never trust SDFGI on frame one. SDFGI converges in about 30 frames (P1) and is darker right…
  6. Volumetric fog quality lives in Project Settings, and that is where its cost is. Four Games calls volume size 64 too low and 256 a good…
  7. The base look must hold on every renderer; tiers only add. Mobile ignores SDFGI, VoxelGI, SSR, SSAO, SSIL and volumetric fog…
  8. CompositorEffect is GLSL compute, not .gdshader (Acerola 9:39). The docs list Forward+ and Mobile, but the docs pattern (color as a…

What it can do on your machine

Read from SKILL.md and the folder at commit f6f8ab7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 9 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npx, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Scenario Godot Rendering Lighting loads about 4.9k tokens when it runs, and up to ~20k if it reads all its reference files. Until then it costs about 131 tokens; SKILL.md has 2,093 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~131
When it runs · the whole SKILL.md, loaded when a task matches
~4.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~20k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from scenario-labs/skills at commit f6f8ab7, republished under its MIT licence (© scenario-labs). 2,093 words, ~4,900 tokens.

Download SKILL.mdSave it as .claude/skills/scenario-godot-rendering-lighting/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
scenario-godot-rendering-lighting
description
Use when lighting or rendering a Godot 4.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps without a mouse, tune WorldEnvironment, tonemapper (AgX, ACES, Filmic), glow, fog, volumetric fog and god rays, shadows and shadow acne, quality presets for PC and phones, Compositor post effects, or when 'my scene looks flat', 'too dark indoors', 'light leaks', 'lightmap is black', 'looks different on mobile'.
license
MIT

Godot rendering and lighting (lighter / graphics technical artist)

Target: Godot 4.7.2.stable, macOS Apple Silicon (Metal by default).

Expert level here means that lighting comes from a measured loop: a calibration scene, one variable at a time, a rendered image looked at after every change, numbers on that image, and a GPU cost for every effect. The renderer and the GI method are chosen first, because they decide what the other settings can do. The art direction (value pattern, warm and cool, focal contrast) is judged on pixels the agent actually opened, never on the inspector. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

REQUIRED BACKGROUND: scenario-godot-expert (channels, gd_run, the review loop, 4.7 traps).

Stance (the expert delta)

  1. Use lightmaps for static scenes. SeasonalAsh measured on an RTX 4060 that SDFGI roughly halves fps, VoxelGI runs at 60 to 80 fps, and lightmaps are fastest: lightmaps "9 times out of 10" unless the world is destructible (SeasonalAsh 13:07, 17:48). In 4.7.2 an agent can bake them: the editor job presses "Bake Lightmaps" itself (P7). Dynamic geometry or a moving sun means SDFGI or VoxelGI; static means LightmapGI plus ReflectionProbes.
  2. Calibrate on a lookdev scene before lighting the level. Brackeys uses guide spheres (dark, white, mirror) and Display > Lighting (Brackeys 7:19, 28:53). Picster keeps the primitive blockout for later retests (Picster 2:05, 1:15:35). lookdev.gd builds an exterior and a sealed room.
  3. Pick the tonemapper by look, then retune exposure. Brackeys and Wild Ox use AgX; SeasonalAsh and LegionGames use ACES. Measured: AgX gives the lowest p95, no clipping, and keeps an orange emitter orange where Filmic and ACES push it to yellow (P5). AgX is also the costliest tonemapper, which matters on phones (docs). A new Environment is Linear (P1): always set it.
  4. Make emission readable on two levels. Glow makes an emitter look bright; a real light (or baked GI) makes it light the scene (Brackeys 13:56, Gamefromscratch 7:09). Glow defaults changed in 4.6 (Screen, intensity 0.3, levels 2 to 4 at 0.8/0.4/0.1, P15): retune scenes made before 4.6.
  5. Never use SDFGI and VoxelGI together, and never trust SDFGI on frame one. SDFGI converges in about 30 frames (P1) and is darker right after enabling (P8). GDQuest retunes the tonemap after turning it on.
  6. Volumetric fog quality lives in Project Settings, and that is where its cost is. Four Games calls volume size 64 too low and 256 a good compromise; god rays need anisotropy about 0.7 and a shorter length (Four Games 0:32 to 3:52). Raise one hero light's Volumetric Fog Energy, drop a flashlight's to 0.1 (Brackeys 19:52, LegionGames 2:08). Measured: 512 costs +3.9 ms at 1080p (P9).
  7. The base look must hold on every renderer; tiers only add. Mobile ignores SDFGI, VoxelGI, SSR, SSAO, SSIL and volumetric fog; Compatibility the same minus SSAO; each prints one WARNING line at load (P4). Fog, glow, tonemap, lightmaps and probes carry the look everywhere [added]. Renderer fallback to Compatibility is silent since 4.4 and fallback_to_opengl3 defaults to true (docs, P15): set it false on PC so a bad driver fails loudly; on Android keeping it true is a choice, so test the Compatibility look.
  8. CompositorEffect is GLSL compute, not .gdshader (Acerola 9:39). The docs list Forward+ and Mobile, but the docs pattern (color as a storage image) logs 172 errors on Mobile in 4.7.2 because Mobile's color buffer lacks the storage bit, and Compatibility ignores the effect silently (P12). Ship it on Forward+ and guard Mobile. Callbacks run on the render thread: mutex any state shared with the main thread, pad push constants to multiples of 16 bytes, and remember upscaling runs after post (docs). For post with UI on top, a CanvasLayer ColorRect works everywhere (Lukky).

Establish first

InputDefault if not given
Target platforms and renderer per platformForward+ desktop. Project default rendering_method.mobile="mobile", .web="gl_compatibility"
Frame budget and reference GPU60 fps (16.6 ms) on PC; measure on Vulkan (Metal reports 0 GPU ms)
Static or dynamic world: moving sun, destructible geometry, sizestatic interior: lightmaps; open day/night: SDFGI; mid-size dynamic: VoxelGI
Mood references and time of dayone image or three words ("cold dawn, foggy, hopeful")
Hero subject and camera(s)a Camera3D path, else the scene's current camera
Asset sourceglTF from blender-expert or scenario-* skills: check UV2 and stray emission

Workflow

Load the toolkit: sys.path gets skills/scenario-godot-expert/scripts and skills/scenario-godot-rendering-lighting/scripts, then import gd_lighting as gl and gl.install(P). Full code: references/procedures.md.

  1. Renderer. Read project.godot (rendering_method, Jolt, fallback) (P1). gl.capture_renderers(P, scene) captures one view per renderer and returns the WARNING lines. GATE: renderer written in project.godot; parity sheet opened; dropped features listed in the handoff.
  2. Lookdev. gl.build_lookdev(P) (P3), capture the three cameras. GATE: look_checks p95 minus p05 above 0.25, clipped under 5 percent; opened: dark sphere shows form, white not clipped, mirror reflects sky.
  3. GI and bake.
    • static: gi_bake.gd:prepare (sun Dynamic, others Static, hidden lights Disabled, UV2 check), then the windowed gi_bake.gd:lightmap editor job (P7);
    • mid-size dynamic: gi_bake.gd:voxelgi, windowed (P6);
    • open world: SDFGI with occlusion, bounce feedback 0.5 or less, Y scale 75 or 50 percent, max distance below camera far, captured after 40 frames or more (P8).
    • Add ReflectionProbes with lightmaps (no specular otherwise). GATE: audit has no GI errors; bake files exist; interior capture opened and checked for leaks, seams and dark patches.
  4. Key, fill and practicals. Lights at their sources, matching color; shadows only on key lights; candles unshadowed, short range; artificial lights below the sun (Brackeys, SeasonalAsh). Run gl.audit(P, scene, ["forward_plus", "mobile"]) (P2). GATE: no error flags; squint(img) opened with one focal value; focal_contrast at least 0.05.
  5. Environment and post. gl.sweep one variable at a time: tonemapper (tonemap_variants, P5), exposure, glow, fog, volumetric fog (P10), Adjustments last (cool shadows, warm lights via the color-correction gradient, Picster 45:07). GATE: each sheet opened, winner named with its numbers, no variant clipping over 5 percent unless briefed.
  6. Shadows. Sweep shadow_normal_bias first, then shadow_bias (SeasonalAsh 0.05 against the 0.1 default, frames 4:13); blend splits on; max distance set to the playable range (Picster 400 outdoors, default 100). GATE: grazing-angle close-up opened, no stripes, contact shadow attached.
  7. Tiers and cost. graphics_tiers.gd presets through a sweep with call and measure=60 on --rendering-driver vulkan (P11): low and medium use 2 shadow splits, high and ultra 4. Per-effect deltas from the P9 template. On Mobile use MetalFX spatial on Apple, else bilinear (P13). GATE: each tier's GPU ms fits the budget on the target renderer, and the low tier keeps the mood.
  8. Custom post (optional). compositor_tools.gd:attach plus post_effect.gd and a GLSL compute shader (P12). GATE: the effect shows on Forward+; Mobile skips with one warning.
Show full SKILL.md (962 more words)Show less

Expert checklist (state these in the plan)

  • Bake scope. A hidden light still bakes: set Bake Mode Disabled (docs). Meshes default to GI mode Static (P15), so exclude non-playable geometry with GI mode Disabled for faster, better bakes (SeasonalAsh 13:39).
  • Import and repo. glTF meshes/light_baking=2 (Static Lightmaps; the default 1 is plain Static) and meshes/lightmap_texel_size (default 0.2; 0.5 or more on huge scenes that crash the bake) (P15, docs). Never gitignore *.unwrap_cache (keeps UV2 stable); keep .lmbake external (docs).
  • Leaks. Closed, thick walls [added]; LightmapGI Interior plus environment mode Disabled for sealed rooms (docs).
  • Denoiser. rendering/lightmapping/denoising/denoiser is project-wide: 0 JNLM (default), 1 OIDN (needs the external binary) (docs, P15).
  • Shadowmask. LightmapGI.shadowmask_mode: None (0, default), Replace (1, realtime near, baked beyond max distance, best for foliage), Overlay (2, fast cameras). Only the first Dynamic DirectionalLight3D; switch without rebake (docs, P15).
  • Dark indoor bake. Lightmaps ignore Environment ambient: fill lights or bounces first; Spannule's last resort multiplies the EXR and adds ambient at about 8 percent (1JvPYUl1nfo 4:00).
  • SSAO only darkens ambient light: ssao_light_affect defaults to 0.0 (docs, P15).
  • Shadows. Cull Mask does not stop shadow casting: turn off the mesh's Cast Shadow. 88 shadowed positional lights fit the default atlas (quadrants 4+4+16+64, P15). A mesh in all 4 PSSM splits draws 5 times. One visible AreaLight3D in Forward+ taxes every object. Compatibility renders shadowed lights in sRGB, so retune energy (docs).
  • Post. A 3D LUT must be imported as Texture3D (importer="3d_texture", slices/horizontal); a 256x16 strip with 16 slices loads as 16x16x16 (P15). HDR Clamp Exposure compresses only luminance above about 4096 (a 100000 sun pixel became 14988; 50 stayed 50, P15). Debanding is off by default. Exposure and DOF live in CameraAttributes on the Camera3D, quality knobs in Project Settings.

Numbers

ValueWhat it is relative toSource
shadow_bias 0.05default 0.1SeasonalAsh frames 4:13; P1
shadow blur 2 to 3default 1.0SeasonalAsh 5:13
directional max distance 100default; Picster 400 outdoorsP1; Picster 54:08
volumetric fog volume size64 default, 256 good, 512 best; +0.2 to 1.1 (64), +1.5 to 2.7 (256), +3.9 (512) ms at 1080pFour Games 2:44; P9
fog anisotropy 0.7 for god raysdefault 0.2Four Games 0:32; P1
SDFGI convergenceabout 30 frames (enum index 5); capture after 40P1, P8
SDFGI bounce feedbackdefault 0.5; above 0.5 risks runawayP1; Omogonix 28:10
SDFGI max distance204.8 default, camera far 4000P15
lights per meshMobile 8 omni + 8 spot; Forward+ 512 clustered elements per viewdocs
spot shadow anglefails above 89°docs
LightmapGI quality ordersupersampling, then texel size, then qualityBrackeys 34:34
LightmapGI Low bake, lookdev room3.6 to 15 s bake (M5 Max, under load)P7
effect GPU ms at 1080p, tiny sceneSSIL +1.4 to 1.7, SSR +0.9 to 1.3, SDFGI +0.7 to 1.1; SSAO, glow, TAA, SMAA, MSAA 2x each under 0.8 (under 0.5 is noise)P9, Vulkan
tier GPU ms (Forward+ / Mobile)low 1.5 / 0.62, high 2.9 to 4.3 / 1.73, ultra 3.6 to 4.85 / 1.64P11, tiny scene

Effect costs scale with resolution and scene: re-measure with the P9 template before quoting them.

Quality gates

  • Measurable: gl.audit zero error flags per target renderer; gd_run.check_all zero parse errors; look_checks clipped under 0.05, crushed under 0.3, p95 minus p05 above 0.25, focal_contrast at least 0.05; bake files exist and lightmap_textures at least 1; .gitignore has no unwrap_cache; each tier's GPU ms within budget on Vulkan.
  • Visual: open each contact sheet and squint image: one focal area, readable silhouette, warm and cool intent, no leaks, seams, acne or banding, emitters glow, fog does not wash the frame, mobile and low tier keep the mood. references/critique.md is the rubric.

Common mistakes

MistakeWhat it looks likeFix
Leaving Linear tonemapblown highlights, flat skyAgX or ACES, then exposure
Lighting in the editor preview sungame is grayWorldEnvironment and sun in the scene (SeasonalAsh 1:40)
SDFGI plus VoxelGIdouble bounce, costone GI per area
Lightmap meshes without UV2black or garbage bakeadd_uv2 on primitives, Static Lightmaps on glTF
Hidden light still bakedghost lightBake Mode Disabled (prepare does it)
Expecting FSR1 on Mobileidentical to bilinear, warning "FSR1 3D scaling is only available when using the Forward+ renderer"MetalFX spatial on Apple, else bilinear (P13)
docs CompositorEffect on Mobile170+ errors per runstorage-bit guard (post_effect.gd)
Stray emission on imported glTFglowing propsaudit emissive_without_glow, zero it (Gamefromscratch 5:25)
Writing "30" into frames_to_convergewrong enum indexgl.setting_index(key, 30) gives 5
SSAO on, nothing changesAO invisible in direct lightraise ssao_light_affect
LUT as a plain PNGcolor correction ignoredreimport as Texture3D with slices

Handoffs

  • Receives from: scenario-godot-3d-world (level, static and dynamic split, cameras); blender-expert and scenario-* skills (glTF with UV2); scenario-godot-shaders (materials); scenario-godot-vfx (emissive effects).
  • Delivers to: scenario-godot-performance-export (tier table, GPU ms per tier and renderer, settings diff); scenario-godot-ui (graphics settings mapped to graphics_tiers.gd); scenario-godot-shaders (compositor GLSL needs); scenario-godot-expert (sheets, audit JSON, parity notes). Scene and .tres files committed, plus .agent_out/ sheets and JSON.

Godot 4.7 notes

Observed in 4.7.2 (references/expert-notes.md, Observed):

  • LightmapGI.bake does not exist for scripts; the editor button route works (P7). VoxelGI.bake exists but headless saves empty data.
  • GeometryInstance3D.lightmap_scale is gone: use gi_lightmap_texel_scale.
  • New Environment: Linear tonemap, glow Screen at 0.3, SDFGI bounce feedback 0.5.
  • FSR1 is Forward+ only; MetalFX spatial works on Mobile with Metal.
  • GPU timing reads 0 on Metal: profile with --rendering-driver vulkan.
  • AgX arrived in 4.4. Wild Ox reports 4.6 fixed SDFGI and VoxelGI leaks, glow and SSR, so retest 2023 workarounds such as encapsulating boxes (Wild Ox 2:23).

References

© scenario-labs, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 14 other files (scripts, references) in skills/game-engines/godot/scenario-godot-rendering-lighting of scenario-labs/skills.

  • SKILL.md
  • references/critique.md
  • references/expert-notes.md
  • references/gui-paths.md
  • references/procedures.md
  • references/sources.md
  • scripts/agentkit/rendering/compositor/grayscale.glsl
  • scripts/agentkit/rendering/compositor/post_effect.gd
  • scripts/agentkit/rendering/compositor_tools.gd
  • scripts/agentkit/rendering/gi_bake.gd
  • scripts/agentkit/rendering/graphics_tiers.gd
  • scripts/agentkit/rendering/light_audit.gd
  • scripts/agentkit/rendering/lookdev.gd
  • scripts/agentkit/rendering/sweep.gd
  • scripts/gd_lighting.py

Open the folder on GitHubat commit f6f8ab7

Compare with similar skills

Scenario Godot Rendering Lighting next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Scenario Godot Rendering Lighting compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scenario Godot Rendering Lighting this skillscenario-labs/skills946—~4.9kAutomated safety check: PassMIT
Godot Gdscript Patterns925236118/AlphaAgent10310 repos~5kAutomated safety check: PassMIT
2D Map and Scene Generator0x0funky/agent-sprite-forge4.4k—~2.9kAutomated safety check: PassMIT
Godot UI Integrationzimo-xiao-zheng/godot-ui-integration285—~1.5kAutomated safety check: PassMIT
Godot Wechat Minigame Adaptergodothub/godot-minigame187—~1.5kAutomated safety check: PassMIT
AI Game Art Pipelineybuild-ai/ai-game-art-pipeline-skill297—~1.1kAutomated safety check: PassMIT

Similar skills

  • Godot Gdscript Patterns

    925236118/AlphaAgent

    Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization.

    103 GitHub starsUsed in 10 repos~5k tokens
    Game DevelopmentAuto-check passed
  • 2D Map and Scene Generator

    0x0funky/agent-sprite-forge

    Plans and builds 2D game maps and scenes, from tilemaps and parallax backgrounds to HD-2D plates, with collision checks, a playable HTML preview and Tiled, Godot or LDtk export.

    4.4k GitHub stars~2.9k tokensUpdated 5 days ago
    Game DevelopmentAuto-check passed
  • Godot UI Integration

    zimo-xiao-zheng/godot-ui-integration

    Build or revise Godot UI from an approved design, separated art, or a visual reference when scene structure, gameplay binding, and runtime visual verification all matter.

    285 GitHub stars~1.5k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed
  • Godot Wechat Minigame Adapter

    godothub/godot-minigame

    Apply the bundled self-contained Godot WeChat Mini Game adapter kit to an official Godot checkout.

    187 GitHub stars~1.5k tokensUpdated 25 days ago
    Game DevelopmentAuto-check passed
  • AI Game Art Pipeline

    ybuild-ai/ai-game-art-pipeline-skill

    Provider-neutral open-source skill for planning and producing game-runtime art assets and animation: static props/icons, canonical character sheets, combat sprites, 3D/video motion references…

    297 GitHub stars~1.1k tokensUpdated 3 mo ago
    Game DevelopmentAuto-check passed
  • MCP Driver

    RandallLiuXin/GodotMaker

    Runtime debugging and live project inspection via godot-mcp.

    550 GitHub starsUsed in 1 repo~1.1k tokens
    Game DevelopmentAuto-check passed

More from scenario-labs/skills

All 146 skills in this repo
  • Scenario Blender Grease Pencil

    scenario-labs/skills

    A skill your agent uses when drawing or animating with Grease Pencil in Blender 5.x from Python: 2D or 2.5D illustration, frame-by-frame animation, a cutout or part-based 2D character, strokes with…

    946 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check passed
  • Scenario Blender Hair

    scenario-labs/skills

    A skill your agent uses when grooming hair or fur in Blender with hair curves, such as a character hairstyle, animal fur, procedural fur in geometry nodes, or hair cards and mesh hair for games.

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed
  • A skill your agent uses when lighting, rendering or compositing in Blender: light a character, product or hero shot, interior at dusk or night, three-point or motivated lighting, sun and sky, HDRI…

    946 GitHub stars~5k tokensUpdated yesterday
    Auto-check passed
  • Scenario Chatgpt Pet Create

    scenario-labs/skills

    A skill your agent uses when creating a ChatGPT pet or Codex pet with Scenario: hatching an animated companion from a text idea, a character, mascot or brand cue, or reference photos and art; making…

    946 GitHub stars~3.6k tokensUpdated yesterday
    Auto-check passed
  • Scenario Godot Animation

    scenario-labs/skills

    A skill your agent uses when animating characters or scenes in Godot 4.7: AnimationPlayer clips and RESET, AnimationTree state machines and blend spaces built in code, Mixamo or glTF import, loop…

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed
  • Scenario Godot Audio

    scenario-labs/skills

    A skill your agent uses when adding or fixing sound in Godot 4.7: audio buses and effects, volume sliders, 'too many sounds', combat audio with hundreds of enemies, sounds clipping or distorting, 3D…

    946 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check passed

Works with

Questions about Scenario Godot Rendering Lighting

What does Scenario Godot Rendering Lighting do?

A skill your agent uses when lighting or rendering a Godot 4.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps…. Scenario Godot Rendering Lighting is an agent skill from scenario-labs/skills.7 3D scene: pick a renderer (Forward+, Mobile, Compatibility), choose GI (SDFGI, VoxelGI, LightmapGI, reflection probes), bake lightmaps without a mouse, tune WorldEnvironment, tonemapper (AgX, ACES, Filmic), glow, fog, volumetric fog and god rays, shadows and shadow acne, quality presets for PC and phones, Compositor post effects, or when 'my scene looks flat', 'too dark indoors', 'light leaks', 'lightmap is black', 'looks different on mobile'.

When should I use Scenario Godot Rendering Lighting?

Scenario Godot Rendering Lighting fits situations like: rendering a Godot 4.7 3D scene: pick a renderer (Forward+; choose GI (SDFGI; reflection probes); bake lightmaps without a mouse.

How do I install Scenario Godot Rendering Lighting in Claude Code?

Run `npx skills add scenario-labs/skills --skill scenario-godot-rendering-lighting -a claude-code`. Or copy the skill folder (skills/game-engines/godot/scenario-godot-rendering-lighting in scenario-labs/skills) into .claude/skills/scenario-godot-rendering-lighting in your project. Claude Code loads it when a task matches its description.

How do I install Scenario Godot Rendering Lighting in Codex?

Run `npx skills add scenario-labs/skills --skill scenario-godot-rendering-lighting -a codex`. Or copy the skill folder (skills/game-engines/godot/scenario-godot-rendering-lighting in scenario-labs/skills) into .agents/skills/scenario-godot-rendering-lighting in your project. Codex loads it when a task matches its description.

Can I use Scenario Godot Rendering Lighting in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add scenario-labs/skills --skill scenario-godot-rendering-lighting -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scenario-godot-rendering-lighting, .gemini/skills/scenario-godot-rendering-lighting, .github/skills/scenario-godot-rendering-lighting and .opencode/skills/scenario-godot-rendering-lighting in your project.

What does Scenario Godot Rendering Lighting need to run?

Going by SKILL.md and its folder, Scenario Godot Rendering Lighting needs Python for the scripts in its folder and the command-line tools its instructions call (npx). Our summary lists: Python 3; Node.js.

Does Scenario Godot Rendering Lighting access the network?

SKILL.md contains no URLs. Its commands use npx, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Scenario Godot Rendering Lighting safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Scenario Godot Rendering Lighting use?

Scenario Godot Rendering Lighting is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Scenario Godot Rendering Lighting use?

About 4.9k tokens (SKILL.md is roughly 20k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 15k tokens, read only when the agent opens those files.

What are the alternatives to Scenario Godot Rendering Lighting?

Skills that share tags, products or a category with Scenario Godot Rendering Lighting: Godot Gdscript Patterns (925236118/AlphaAgent, 103 stars), 2D Map and Scene Generator (0x0funky/agent-sprite-forge, 4.4k stars), Godot UI Integration (zimo-xiao-zheng/godot-ui-integration, 285 stars) and Godot Wechat Minigame Adapter (godothub/godot-minigame, 187 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scenario Godot Rendering Lighting?

scenario-labs (a GitHub organization) maintains it in scenario-labs/skills, which has 946 GitHub stars. The repository holds 146 skills in this directory. The repository was last updated on October 10, 2026.

Source: scenario-labs/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.