SkillAgentSearch skills...

router

Routes any game-development request to the right skills: detects the engine (Godot, Unity, Unreal, Ebitengine, Bevy, Phaser, PixiJS, three.js, Defold, LÖVE, pygame, Roblox) and the task, then reads the chosen skill.

Install / Use

npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill router

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

90/100

Category

Marketing

Supported Platforms

Universal

Our assessment of router

router scores 90/100 on our quality scale, 239th of 642 Marketing skills we index (top 38%).

Its SKILL.md is 15 KB long, well organised into 15 sections and no code examples: a thorough specification that gives an agent plenty to work with.

With 8,904 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
13/20
Description
15/15
Adoption
17/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 4 days ago, so router is actively maintained.
  • Our last check on 2026-11-02 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

router compared with similar skills

All 4 of these similar skills score higher than router; compare them before choosing.

SkillScoreStarsUpdatedFormat
router (this skill)by gamedev-skills908.9k4d agoSKILL.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md

Frequently asked questions

How do I install router?
Run npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill router. The install tabs above show the steps for each supported agent.
Which AI agents does router work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is router safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is router still maintained?
The repository was last updated 4 days ago, so router is actively maintained.

name: router description: > Routes any game-development request to the right specialized skill(s): it detects the engine (Godot, Unity, Unreal, Bevy, Phaser, PixiJS, three.js, LÖVE, pygame, Roblox) and the task, then reads the chosen skill before acting. Use to make a game or to decide which skill applies — for players, levels, enemies, shaders, art direction, sprites, tiles, textures, 3D assets, UI/UX, cameras, game feel, physics, input, audio, saving, multiplayer, AI, dialogue, procedural generation, or performance, for genres (platformer, roguelike, RPG, FPS, tower-defense, card game, visual novel, survival-crafting, puzzle), and for shipping (game jam, Steam, itch). Start here when unsure which gamedev skill to use.

Master Router — Game-Development Skill Dispatcher

The entry point for game-development work. It fingerprints the project to pick one engine, classifies the task from the request, names the minimal set of specialized skills, and tells you to read them before acting. It dispatches and composes — it does not re-teach engine APIs.

When to use

  • Use at the start of any game-development request — building or debugging a game, level, player, enemy, shader, UI, save system, multiplayer, input, audio, AI, dialogue, procedural content, or visual asset set — to decide which skill(s) to load.
  • Use when the user names an engine or genre, says "make a game", or asks "which skill should I use?".

When not to use: once the right skill is loaded and the task is squarely inside it, work from that skill — don't re-run the router every turn. Re-route only when the task pivots to a new engine or concern (router step 6).

Routing algorithm

  1. Detect engine and version — project fingerprint → at most one engine skill set (or "unknown"), then read the project's version source. §1.
  2. Classify task — phrasing → discipline(s) + at most one genre + workflow(s). §2.
  3. Resolve — the minimal set: engine skill(s) + discipline(s) + genre + workflow(s). §3.
  4. Read (disclosure) — open only the chosen SKILL.md bodies; references/ only on demand. §4.
  5. Compose — order: engine fundamentals → discipline concept → genre glue → workflow. §5.
  6. Fallback — engine unknown or no skill fits → ask or default to Godot; state any gap. §6.

1. Engine detection (project fingerprint)

Scan for the highest-confidence signal; choose exactly one engine. Stop at the first match.

| # | Engine | Primary signal | Skill set root | |:-:|--------|----------------|----------------| | 1 | Godot | project.godot | skills/godot/ | | 2 | Unreal | *.uproject | skills/unreal/ | | 3 | Unity | Assets/ and ProjectSettings/ProjectVersion.txt | skills/unity/ | | 4 | Bevy | Cargo.toml with a bevy dependency | skills/other-engines/bevy-ecs/ | | 5 | Phaser | package.json dep phaser | skills/web-engines/phaser-* | | 6 | PixiJS | package.json dep pixi.js | skills/web-engines/pixijs-rendering/ | | 7 | three.js | package.json dep three | skills/web-engines/threejs-* | | 8 | LÖVE | conf.lua / main.lua calling love.* | skills/other-engines/love2d-core/ | | 9 | pygame | *.py with import pygame | skills/other-engines/pygame-core/ | | 10 | Roblox | *.rbxl(x) / *.project.json (Rojo) | skills/other-engines/roblox-* |

For secondary signals, the Godot-C#/Unity/Bevy and multi-web disambiguation rules, monorepos, and plain-text engine mentions, read references/engine-detection.md.

After identifying the engine, read its version from project metadata or dependency locks before choosing APIs. Existing projects keep their pinned version unless migration is requested; the catalog baseline is only for new projects. The exact version sources are in the detection reference and ../docs/VERSION-SUPPORT.md.

2. Task classification (phrasing → category)

After the engine, read the request for task signals (three additive categories):

  • disciplines (cross-engine concepts): create-game-assets, game-ai, ai-behavior-trees-utility-ai, procedural-gen, dialogue-systems, save-systems, audio-design, shader-programming, physics-tuning, level-design, input-systems, game-feel, camera-systems, game-ui-ux, performance-optimization. Triggered by concept words ("sprite sheet", "art direction", "texture", "pathfinding", "save slots", "fragment shader", "screen shake", "camera follow", "HUD/menu", "optimize/low FPS").
  • genres (whole-game templates): platformer, roguelike, rpg, fps-shooter, tower-defense, card-game, visual-novel, survival-crafting, puzzle. Triggered by genre words ("make a roguelike", "deckbuilder").
  • workflows (process/shipping): game-jam, prototype-fast, steam-publish, itch-publish. Triggered by process words ("publish on Steam", "vertical slice").

File signals sharpen this: *.yarn/*.ink → dialogue-systems/visual-novel; steam_appid.txt → steam-publish; *.inputactions → unity-input-system.

3. Routing table (task → category → skill)

3a. Engine skills — read the one matching the detected engine + sub-task

  • Godot (skills/godot/): language godot-gdscript / godot-csharp; structure godot-nodes-scenes, godot-signals-groups; 2D godot-2d-movement, godot-tilemap; 3D godot-3d-essentials; physics godot-physics; UI godot-ui-control; animation godot-animation; shaders godot-shaders; data godot-resources; audio godot-audio; netcode godot-multiplayer; headless CLI tests godot-gdscript-headless-testing; ship godot-export.
  • Unity (skills/unity/): scripting unity-csharp-scripting; input unity-input-system; physics unity-physics; animation unity-animation; data unity-scriptableobjects; 2D unity-tilemap-2d; AI nav unity-navmesh; ship unity-build-pipeline.
  • Unreal (skills/unreal/): visual scripting unreal-blueprints; C++ gameplay unreal-cpp-gameplay; input unreal-enhanced-input; AI unreal-behavior-trees; VFX unreal-niagara; ship unreal-packaging.
  • Web (skills/web-engines/): phaser-core, phaser-arcade-physics; pixijs-rendering; threejs-scene-setup, threejs-gltf-loading, threejs-materials-lighting.
  • Other (skills/other-engines/): bevy-ecs, pygame-core, love2d-core; Roblox foundation roblox-luau, persistence roblox-datastores, UI roblox-ui, remotes/security roblox-networking, character lifecycle roblox-characters, simulation/queries roblox-physics, and in-Studio operation roblox-studio-workflow.

3b. Disciplines — load with the engine skill (concept ↔ engine API)

| Concept (says:) | Discipline skill | Pairs with (engine API) | |-------------------|------------------|-------------------------| | art direction, game assets, sprites, tilesets, textures, icons, 3D props | create-game-assets | engine importer/rendering skill; imagegen when available | | enemy AI, behavior tree, pathfinding, steering | game-ai | unity-navmesh / unreal-behavior-trees / Godot nav | | BT runtime, blackboard, decorator, selector/sequence, utility AI, response curve, consideration | ai-behavior-trees-utility-ai | game-ai (model choice) / unreal-behavior-trees (engine assets) | | procedural, noise, seed, dungeon generator | procedural-gen | engine tilemap/grid skill | | dialogue, Yarn, Ink, conversation tree | dialogue-systems | engine UI skill | | save/load, slots, persistence | save-systems | roblox-datastores / engine IO | | adaptive music, mixer, ducking, SFX | audio-design | godot-audio / Unity AudioMixer | | shader, fragment, dissolve/outline | shader-programming | godot-shaders / engine material | | jitter, tunneling, fixed timestep | physics-tuning | godot-physics / unity-physics | | whitebox, blockout, tile layout, pacing | level-design | godot-tilemap / unity-tilemap-2d | | rebind, gamepad, input buffering | input-systems | unity-input-system / unreal-enhanced-input / Godot InputMap | | screen shake, hit-stop, juice, squash & stretch, "make it punchy" | game-feel | engine animation/tween + camera-systems (shake) | | camera follow, deadzone, look-ahead, orbit, first-person | camera-systems | godot-2d-movement / godot-3d-essentials / Cinemachine | | HUD, menu, UI layout, scaling, safe area, focus nav | game-ui-ux | godot-ui-control / Unity UI (UGUI/UI Toolkit) | | low FPS, optimize, draw calls, GC spike, pooling, profiler | performance-optimization | engine profiler + physics-tuning |

For Roblox, compose cross-engine concepts with the focused engine skill: HUD/menu requests use roblox-ui + game-ui-ux (+ input-systems for gameplay bindings); remote exploit or replication requests use roblox-networking + roblox-luau; respawn/rig requests use roblox-characters; physical simulation/query requests use roblox-physics (+ physics-tuning for stability); direct place editing also uses roblox-studio-workflow.

3c. Genres — compose engine + disciplines (bind * to the detected engine)

| Genre (says:) | composes | |-----------------|----------| | platformer, jump, double jump | godot-2d-movement (or engine physics) + godot-tilemap/unity-tilemap-2d + level-design + camera-systems + game-feel | | roguelike, procedural dungeon, permadeath | procedural-gen + godot-tilemap/unity-tilemap-2d + game-ai + save-systems + game-feel | | RPG, stats, inventory, quests | godot-resources/unity-scriptableobjects + dialogue-systems + save-systems + game-ui-ux | | FPS, first-person, hitscan | godot-3d-essentials/unreal-cpp-gameplay + input-systems + game-ai + camera-systems + game-feel | | tower defense, waves, lanes | game-ai + engine movement + level-design + game-ui-ux | | card game, deckbuilder, TCG | godot-resources/unity-scriptableobjects + game-ui-ux (+ engine UI) | | visual novel, branching story | dialogue-systems + save-systems + game-ui-ux | | survival, crafting, gathering | save-systems + godot-resources/unity-scriptableobjects + procedural-gen + game-ui-ux | | puzzle, match-3, grid logic | godot-tilemap/unity-tilemap-2d + level-design + game-feel |

3d. Workflows — engine-independent process & shipping

game-jam (jam, 48-hour, Ludum Dare/GMTK) · prototype-fast (vertical slice, MVP, greybox) · steam-publish (Steam, Steamworks, depot; steam_appid.txt) · itch-publish (itch.io, butler; .itch.toml).

For the exhaustive per-skill trigger list and every engine binding, read references/routing-table.md.

4. Read protocol (progressive disclosure)

  1. Preloaded: only each skill's name + description are in context. Decide from those plus the fingerprint — do not pre-read bodies.
  2. On selection: read the body of each chosen skills/<category>/<name>/SKILL.md — and only those. Never bulk-load a whole category.
  3. On demand: read a skill's bundled references/ files only when the subtask needs that depth (the skill body says when).
  4. Re-route on pivot: if the task changes (movement → saving), select and read the newly relevant skill instead of keeping everything loaded.

Announce what you load and why, e.g.: "Detected Godot (project.godot). Loading godot-2d-movement for the controller and platformer for jump feel; will open the platformer skill's feel-tuning.md reference if you want coyote-time/buffering."

5. Composition rules

  • One engine set, additive concepts. Exactly one engine skill set; add the disciplines the task needs and usually at most one genre. Workflows attach independently.
  • Order: engine fundamentals → discipline concept → genre orchestration → workflow. For asset production, approve the visual target before generating a family, then finish with the engine import settings and an i

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars8.9k
CategoryMarketing
Updated4d ago
Forks905

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions