Agent skill

Scenario Unreal Materials

by scenario-labs in scenario-labs/skills

A skill your agent uses when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens…

MITAuto-check passedGame Development

Install Scenario Unreal Materials

skills CLI
$ npx skills add scenario-labs/skills --skill scenario-unreal-materials -a claude-code

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

GitHub CLI
$ gh skill install scenario-labs/skills scenario-unreal-materials --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/unreal/scenario-unreal-materials .claude/skills/scenario-unreal-materials && 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-unreal-materials
GitHub stars
946
Token cost
~4.6k tokens
SKILL.md length
2,077 words
Files
7 (incl. scripts, references)
Skills in repo
146
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens…

  • Works in 10 steps: Probe and decide. P0 um.probe() lists… → Plan the family. One master per domain… → Textures (P2): pack_channels,… → …
  • A UE5 task involves materials
  • SKILL.md covers Stance (the expert delta), Establish first, Workflow and Numbers, plus 5 more sections
  • Runs Python scripts from its folder; calls npx

What it does

Scenario Unreal Materials is an agent skill from scenario-labs/skills. Use when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens, decals, edge wear and dirt, landscape layers and RVT, toon or cel shading, "too many shaders" or shader permutations, static switches, usage flags, texture compression (BC7, normal maps, ORM packing, sRGB), texture memory, or "is this material expensive".

Its SKILL.md is about 4.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 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 and Shaders. It works with Unreal Engine. 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

  • A UE5 task involves materials
  • Textures: a master material and instances for a kit
  • Blendable vs Adaptive GBuffer
  • Emissive screens

Example prompts

  • “too many shaders”
  • “is this material expensive”
  • “/scenario-unreal-materials”

Requirements

  • Python 3
  • Node.js

Workflow steps

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

  1. Probe and decide. P0 um.probe() lists what 5.8 really exposes; P1 reads the ini and runs um.choose_gbuffer_format(targets, needs), whose…
  2. Plan the family. One master per domain and blend mode (surface, glass, screen, decals, UI Material, landscape), each with its switches and…
  3. Textures (P2): pack_channels, import_textures, audit_textures(apply=True), albedo_stats. GATE: audit passes; resident size at most 2048…
  4. Build masters (P3, P4): um.build_kit_surface or a template: texture-gating switches, an If for the paint-mask source, Custom Primitive…
  5. Instances (P5, P6, P16): only make_presets sets static switches; children change values; Custom Primitive Data varies placed actors. GATE…
  6. Usage flags and shaders (P7): pin needs on instances, then clear the parent; auto usage off; Used with Static Mesh off on decal, UI and…
  7. Special families. Screens: emissive calibrated with the lighter; TSR smearing on scrolling text gets the experimental Temporal…
  8. Cost A/B (P9, live editor): fixed camera, r.ScreenPercentage 100, warm-up, CSV profile, medians of GPU and pass time, cost_census beside…
  9. Look review (P10, P15): preset board under the level lighting, buffer visualizations, Substrate views. For a Substrate surprise, open…
  10. Cooked check and handoff (P17): listtextures, stat streaming and r.Streaming.PoolSize through texture_memory_findings; hand over reports…

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 1 file 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 Unreal Materials loads about 4.6k tokens when it runs, and up to ~32k if it reads all its reference files. Until then it costs about 113 tokens; SKILL.md has 2,077 words of instructions outside code blocks.

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

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,077 words, ~4,628 tokens.

Download SKILL.mdSave it as .claude/skills/scenario-unreal-materials/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
scenario-unreal-materials
description
Use when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens, decals, edge wear and dirt, landscape layers and RVT, toon or cel shading, "too many shaders" or shader permutations, static switches, usage flags, texture compression (BC7, normal maps, ORM packing, sRGB), texture memory, or "is this material expensive".
license
MIT

Unreal materials (master materials, Substrate, textures, shader cost)

Expert level means a few master materials whose instances cover the kit, a known and budgeted permutation count, cost proven in milliseconds on a fixed camera, and physically plausible values before any artistic push. The graph is authored once (scripted build or template); everything else is instances, Custom Primitive Data and textures that follow a role policy. Never trust the instruction count or a pretty preview. 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-unreal-expert (channels, review loop, 5.8 traps).

Status (2026-09-24): Unreal is not installed; offline tests pass (tests/code/unreal-materials/run_all.sh, editor layer on a fake unreal). Every snippet is not yet run in Unreal: run P0 first.

Stance (the expert delta)

  • Permutations = usage flags x unique static parameter sets across instances (x quality levels with a Quality Switch), never a node count. A parent flag adds a shader row to every unique child (Lauf and Nadro, Fortnite [wobQ8ZKQpbc 00:24:25, 00:05:32]); parents carry the fewest flags, instances opt in (5.8 Usage Flag Overrides [verify]). Before adding a switch, count the instances that would set it (switch_ranking; Fortnite kept its top 10 [00:29:31]).
  • A static switch must gate texture samples, or heavy math most instances skip. Anything else is an If (parameter into A, 0.5 into B, A > B pin, never A == B), an Enum-bound scalar or a Channel Mask Parameter; the Static Component Mask Parameter is obsolete (Lauf [00:40:24, 00:40:56, 00:42:35]). An editable switch at default still sets the HSPR tag (5.7).
  • The instruction count is not cost. Sine plus cosine read +2 but cost about 40 GCN cycles; a fetch waits about 200 (Swierad [y0QASid1v8w 00:20:57, 00:35:57]). Math independent of the fetch hides inside that wait (a screen's scanlines are nearly free); math on the sampled value is paid in full [00:39:34, 00:46:03]. Budget samples and transcendentals (cost_census), open every material function ("cheap" in a name is not a measurement [00:22:31]), decide on ms at a fixed camera.
  • Substrate starts from one slab (Morgan, Epic [SqPaL8HS_Lw 00:25:45]): a Slab or the Metalness helper, never a hand-added Substrate Shading Model node (the conversion target, Substrate overview). Blendable is a ceiling for every platform, SM6 included (5.7 article); Adaptive falls back per platform by itself and costs 20 to 80 B/px (663 MB at 4K), about +15% cook and forced DBuffer decals (Ben Cloward [P5I38f2O6W8 00:05:46, 00:06:54]). Converting a material is one-way.
  • Metal next to paint is two slabs, not gray metallic (gray reads as plaster, Ben [VrY_SSvWdQ4 00:05:39]). With Use Parameter Blending a Horizontal Blend is near-lossless and one slab everywhere (Morgan [00:37:35]): mask sharpness is then artistic, not cost. "Mix exactly 0 or 1 evaluates one slab" holds only without parameter blending, on Adaptive [00:29:38]. Parameter blending on a Vertical Coat is lossy and propagates beneath: plan it early [00:38:08, 00:38:43].
  • Detail comes from packing and tiling, not resolution. Two samples per terrain layer (CR + NOH), a 2K game ceiling, compression by role, sRGB only on color, packed normals never as Normalmap, BC7 for unrelated channels (Ben [-UZlUUQSGgQ 00:12:36], [gjOO5g4cgng 00:11:02]; Sumo [SAr7oPKsgLE 00:29:20]; textures doc). Memory truth is the Platforms panel and listtextures in a cooked build; RDO shrinks disk, not memory.
  • Glass is matter, not opacity: Colored Transmittance only when tinted (Gray is cheaper), Surface Translucency Volume, Pixel Normal Offset for flat panes, slab Simple Volume with Transmittance-To-MFP (Ben [sf-K257zWh8 00:01:39, 00:09:17]).
  • An RVT is a cache captured orthographically at time 0: no Time, Panner, camera distance, parallax or MPC in the write pass; a page change redraws all its writers; each distinct RVT sampled has a large fixed cost (PrismaticaDev [RLEPA16QDRw 00:20:14, 00:11:59, 01:04:29]).

Establish first

InputWhat it changesDefault when silent
Platforms and frame rateGBuffer format (Blendable caps all), closures, samplers (16 on ES3.1), Adaptive-only featuresconsole 60 Hz and PC: Blendable, 1 closure
Project Substrate stater.Substrate in the ini (P1); upgraded projects stay legacyread it, never assume
StylePBR; Toon BSDF (per asset, experimental); post-process EV cel (whole world)PBR
Architecturelean master or Material Layering System (Sumo), by library size and projected permutations (lauf_permutations)lean master, under 10 presets
World-wide values (wetness, alert state)MPC: at most 2 per material; adding parameters recompiles every user (instances doc)one game-wide, one per level
Mesh types per familyusage flags: static, Nanite, skeletal, cloth, Niagara, decal, UIstatic + Nanite
Texture sourcespacking, DirectX green, texel density, source sizeORM packed, DirectX, 2K
Budgetssamples, transcendentals, unique static sets, shaders, BasePass ms, texture poolproject decision; lint warns above 12 samples [added]

Workflow

  1. Probe and decide. P0 um.probe() lists what 5.8 really exposes; P1 reads the ini and runs um.choose_gbuffer_format(targets, needs), whose reasons state the ceiling and the fallback. GATE: CANDIDATES corrected; the format decision written.
  2. Plan the family. One master per domain and blend mode (surface, glass, screen, decals, UI Material, landscape), each with its switches and what they gate, approved presets, usage flags per mesh type, sample and closure budgets, MPCs. GATE: every switch gates a texture and has a switch_ranking count; channel picks are Channel Mask Parameters; architecture written.
  3. Textures (P2): pack_channels, import_textures, audit_textures(apply=True), albedo_stats. GATE: audit passes; resident size at most 2048; lint_graph(g, textures=...) finds no sampler mismatch; normals keep Normalize after making Mips; albedo sRGB 20 (50 rough) to 240, metals at least 180.
  4. Build masters (P3, P4): um.build_kit_surface or a template: texture-gating switches, an If for the paint-mask source, Custom Primitive Data for per-actor wear and dirt, Specular = 0.5 x (1 - cavity) as specular occlusion. Substrate: the Metalness helper feeds a base slab, a bare-metal slab takes albedo 0 and a measured F0, a parameter-blended Horizontal Blend takes the wear mask. Options: value-clamped ID masks, 4 bands per channel (Sumo [00:14:54]); world-aligned texture and normal across modular seams, 3 samples per texture (Ben [pXOknekvmwE 00:12:57]); world-space directional dust (Sumo [00:20:11]). GATE: no failed links; lint_graph free of fail and warn; one closure; clean compile log.
  5. Instances (P5, P6, P16): only make_presets sets static switches; children change values; Custom Primitive Data varies placed actors. GATE: unique sets at most the preset count, no override at default, HSPR only on presets; audit_instance_values_project clean (dielectric F0 at most 0.08, metal albedo 0, Metallic 0 or 1).
  6. Usage flags and shaders (P7): pin needs on instances, then clear the parent; auto usage off; Used with Static Mesh off on decal, UI and Niagara-only materials (Nadro [00:18:38]); shader_count per root (an upper bound). 5.8 compiles only connected, non-zero outputs (r.Material.UseShaderCompilationParameters): deleting nodes to strip shaders is folklore. Skin-cache and Slate levers (P7) only after measuring. GATE: shaders within budget; the fallback board shows no gray default material.
  7. Special families. Screens: emissive calibrated with the lighter; TSR smearing on scrolling text gets the experimental Temporal Responsiveness node, masked, with r.Velocity.TemporalResponsiveness.Supported=1 and a small WPO on Nanite meshes (5.7 article). Decals (P14) end in Convert To Decal; overlapping DBuffer-expression decals do not blend; each receiver's Decal Response covers only the channels its decals write (decal_response_for). Landscape P11, stylized P12 and P13, switch triage P8. GATE: references/critique.md for the family.
  8. Cost A/B (P9, live editor): fixed camera, r.ScreenPercentage 100, warm-up, CSV profile, medians of GPU and pass time, cost_census beside them. GATE: deltas within budget; instruction counts recorded as context only.
  9. Look review (P10, P15): preset board under the level lighting, buffer visualizations, Substrate views. For a Substrate surprise, open Window > Substrate first: features in downgrade order, parameter-blending preview (Morgan [00:12:51, 00:38:43]). ue_review.review_images runs before anyone looks. GATE: critique rubric passes.
  10. Cooked check and handoff (P17): listtextures, stat streaming and r.Streaming.PoolSize through texture_memory_findings; hand over reports, captures, open [verify] items.
Show full SKILL.md (777 more words)Show less

Numbers

ValueRelative toSource
Specular 0.5 = F0 0.04 (4%)90 to 98% of non-metalsBen [fePsD_8p9vM 00:12:09]
Dielectric F0 at most 0.08; gems, carbon fiber up to about 0.18legacy Specular spans IOR 1 to 1.788Morgan [00:09:30]
Metal: albedo 0, F0 average at least 0.5 (doc) or 0.6 (Ben)Substrate slabBen [a94Lpu1_4dg 00:16:16]
Base color sRGB 20 to 240, floor 50 when rough; metals at least 1808-bit sRGBBen [fePsD_8p9vM 00:05:28, 00:22:48]
Glass IOR 1.5, MFP thickness 0.02; frosted roughness 0.2 to 1rough refraction onBen [sf-K257zWh8 00:11:02, 00:17:16]
10 shaders, 20 with Skeletal, 27 with Niagara mesh, 186 with every flagone material, project-dependentNadro [00:06:28, 00:07:05]
Fetch about 200 cycles; multiply 4; sine about 20AMD GCN: a ranking, not Apple truthSwierad
BC1 2048 = 2.66 MiB with mips; BC3, BC5, BC7 double; BC6H one eighth of RGBA16FGPU memorytextures doc

Quality gates

  • Measurable: lint_graph (with textures= and project budgets=) free of fail and warn; census within presets; audit_textures and audit_instance_values_project pass; shader_count per root; BasePass, Translucency, DBuffer ms A/B; Substrate Material Count 1 on Blendable; VirtualTextureUpdate near zero when still; cooked texture_memory_findings clean; no blank frame.
  • Visual (references/critique.md): transitions read as two materials; wear on edges, dirt in cavities, crevices darker in the Specular buffer; no tiling or seams from far; glass free of silhouette seams; screens neither clipped nor smeared; no gray fallback on any mesh type; toon bands stable under a sun sweep.

Common mistakes

MistakeWhat it looks likeFix
Budgeting pixel instructions"under 200" passes, the frame is still slowsamples and transcendentals, measured ms
Switch for a UV channel, tint or mask channela shader map per unique instanceIf, Enum or Channel Mask
Parent flag "just in case"; decal or UI material keeping Used with Static Meshevery unique child compiles another rowinstance overrides, auto usage off, flag off
Deleting nodes "to strip shaders"no change in 5.8check ListShaders
Gray metallic wearchalky, plaster edgestwo slabs, parameter-blended Horizontal Blend
Sharpening masks "for cost" under parameter blending or Blendableharsher look, no gainmask_cost applies only without them
Blendable "for the weaker platform"SM6 platforms lose Adaptive featuresAdaptive falls back per platform
Adaptive on a 60 Hz console gameup to 5x GBuffer memory, forced DBufferBlendable
Substrate Shading Model node added by handconversion path in a new graphSlab, or Metalness helper into a Slab
Packed NOH as Normalmap; sRGB on masks; sampler left after recompressionflat terrain, shifted roughness, compile errorsBC7 or Masks, sRGB off, Fixup Mismatched Samplers
Mips disabled to fix blur; normals not normalized after mipsshimmer, flat distant panelskeep mips; normalize, or composite roughness
Time, Panner or MPC in the RVT write passfrozen or stale pagesread pass or RVT Replace
Temporal Responsiveness without its cvartext still smearscvar, mask, small WPO on Nanite

Handoffs

  • Receives: textures from scenario-maya-lookdev, scenario-zbrush-paint-render, scenario-blender-texturing-shading or Substance (role suffixes, DirectX normals), or through scenario-unreal-pipeline-automation (Interchange); meshes with slots named by family; exposure targets from scenario-unreal-lighting-rendering.
  • Delivers: to scenario-unreal-world-building, masters, presets and instances (paths, parameters, CPD indices), the landscape master, RVT writer rules, decals and receivers' Decal Response. To scenario-unreal-lighting-rendering, emissive and glass materials, Substrate state and GBuffer format, albedo in range. To scenario-unreal-vfx, Niagara materials (flag on the instance, Used with Static Mesh off). To scenario-unreal-performance, census, lint, texture and cooked-memory reports. To scenario-unreal-pipeline-automation, audit_rules() and the permutation gate.

UE 5.8 notes

  • Substrate is on for new projects only, Blendable by default (Adaptive in the Automotive and Architectural templates); 5.8 adds EON rough diffuse, removes SheenQuality, approximates F90 on Blendable, ships the experimental Toon BSDF.
  • ListShaders and Total Shaders are upper bounds; ISMs need no flag on GPU Scene platforms; a StaticSwitch mixing Material Attributes and scalars is a validation error; GetMaterialUsedTextures replaces GetUsedTextures.
  • 5.7: HSPR tag, MPC overrides, Material Diff, Fixup Mismatched Samplers, experimental Temporal Responsiveness; the Vector Parameter RGBA pin shifts scripted pin indices. Enum-bound scalars are in the 5.7 release notes; Unreal Fest presented them as 5.8.
  • Usage Flag Overrides, the validation database, the Experiments panel: shown at Unreal Fest, absent from the saved notes [verify].
  • Mac: Adaptive needs SM6; advanced Substrate visualization is Win64 DX12 only; virtual textures are on by default since 5.6.

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 6 other files (scripts, references) in skills/game-engines/unreal/scenario-unreal-materials of scenario-labs/skills.

  • SKILL.md
  • references/critique.md
  • references/expert-notes.md
  • references/gui-paths.md
  • references/procedures.md
  • references/sources.md
  • scripts/ue_materials.py

Open the folder on GitHubat commit f6f8ab7

Compare with similar skills

Scenario Unreal Materials 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 Unreal Materials compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Scenario Unreal Materials this skillscenario-labs/skills946—~4.6kAutomated safety check: PassMIT
UMG Material MCPwinyunq/UnrealMotionGraphicsMCP210—~913Automated safety check: PassMIT
Dream Shader CreateTypeDreamMoon/DreamShader106—~1.9kAutomated safety check: PassMIT
Dream Shader DecompileTypeDreamMoon/DreamShader106—~2.9kAutomated safety check: PassMIT
Dream Shader VerifyTypeDreamMoon/DreamShader106—~2.1kAutomated safety check: PassMIT
Game DeveloperJeffallan/claude-skills12k—~1.5kAutomated safety check: PassMIT

Similar skills

  • UMG Material MCP

    winyunq/UnrealMotionGraphicsMCP

    Creates, edits and compiles Unreal Engine 5.8 material assets as one HLSL Custom node through the UMG MCP bridge, instead of editing .uasset files directly.

    210 GitHub stars~913 tokensUpdated 2 mo ago
    Game DevelopmentAuto-check passed
  • Dream Shader Create

    TypeDreamMoon/DreamShader

    Write a new DreamShader source from a plain-language description — a material, material function, layer, material instance or Custom Pass pipeline — then check and compile it headlessly to prove it…

    106 GitHub stars~1.9k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Dream Shader Decompile

    TypeDreamMoon/DreamShader

    Export an existing Unreal material, material function, layer, layer blend, material instance or Custom Pass pipeline back into DreamShaderLang source headlessly, so a hand-built material graph or…

    106 GitHub stars~2.9k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Dream Shader Verify

    TypeDreamMoon/DreamShader

    Check and compile DreamShader sources headlessly — one file or the whole DShader tree — without opening the Unreal editor, and read back every diagnostic with its file, line and code.

    106 GitHub stars~2.1k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Game Developer

    Jeffallan/claude-skills

    Covers game programming in Unity and Unreal Engine: ECS design, physics, multiplayer networking, shaders and profiling toward a 60 FPS target.

    12k GitHub stars~1.5k tokensUpdated 8 days ago
    Game DevelopmentAuto-check passed
  • Gamedev Shaders

    ericrisco/rsc-harness

    A skill your agent uses when authoring or debugging a shader, material, VFX, or full-screen post-process in a game engine — Godot 4.x .gdshader, Unity 6 URP/HDRP, Unreal 5.x Materials, effect…

    180 GitHub stars~3.6k tokensUpdated yesterday
    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 Unreal Materials

What does Scenario Unreal Materials do?

A skill your agent uses when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens…. Scenario Unreal Materials is an agent skill from scenario-labs/skills. Use when a UE5 task involves materials or textures: a master material and instances for a kit, Substrate or legacy, Blendable vs Adaptive GBuffer, glass, emissive screens, decals, edge wear and dirt, landscape layers and RVT, toon or cel shading, "too many shaders" or shader permutations, static switches, usage flags, texture compression (BC7, normal maps, ORM packing, sRGB), texture memory, or "is this material expensive".

When should I use Scenario Unreal Materials?

Scenario Unreal Materials fits situations like: A UE5 task involves materials; textures: a master material and instances for a kit; blendable vs Adaptive GBuffer; emissive screens.

How do I install Scenario Unreal Materials in Claude Code?

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

How do I install Scenario Unreal Materials in Codex?

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

Can I use Scenario Unreal Materials 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-unreal-materials -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-unreal-materials, .gemini/skills/scenario-unreal-materials, .github/skills/scenario-unreal-materials and .opencode/skills/scenario-unreal-materials in your project.

What does Scenario Unreal Materials need to run?

Going by SKILL.md and its folder, Scenario Unreal Materials 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 Unreal Materials 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 Unreal Materials 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 Unreal Materials use?

Scenario Unreal Materials 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 Unreal Materials use?

About 4.6k tokens (SKILL.md is roughly 19k 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 27k tokens, read only when the agent opens those files.

What are the alternatives to Scenario Unreal Materials?

Skills that share tags, products or a category with Scenario Unreal Materials: UMG Material MCP (winyunq/UnrealMotionGraphicsMCP, 210 stars), Dream Shader Create (TypeDreamMoon/DreamShader, 106 stars), Dream Shader Decompile (TypeDreamMoon/DreamShader, 106 stars) and Dream Shader Verify (TypeDreamMoon/DreamShader, 106 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Scenario Unreal Materials?

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.