roguelike
Designs run-based roguelikes and roguelites in any engine: run structure, permadeath, meta-progression, seeded and daily runs, turn order and symmetric field of view. Use for NetHack- or Hades-style games, or runs that feel cheap.
Install / Use
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill roguelikeInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
OtherSupported Platforms
Our assessment of roguelike
roguelike scores 94/100 on our quality scale, 36th of 330 Other skills we index (top 11%).
Its SKILL.md is 7.0 KB long, well organised into 19 sections with 3 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.
Maintenance, license and trust
- The repository was last updated 4 days ago, so roguelike is actively maintained.
- Our last check on 2026-11-16 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 foundOur 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.
roguelike compared with similar skills
All 4 of these similar skills score higher than roguelike; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| roguelike (this skill)by gamedev-skills | 94 | 8.9k | 4d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
Frequently asked questions
- How do I install roguelike?
- Run
npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill roguelike. The install tabs above show the steps for each supported agent. - Which AI agents does roguelike 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 roguelike 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 roguelike still maintained?
- The repository was last updated 4 days ago, so roguelike is actively maintained.
Skill content
View source on GitHubname: roguelike description: > Build a roguelike: turn-based grid movement, procedural dungeons, permadeath, field-of-view, and loot tables. Use for a roguelike/roguelite or turn-based grid dungeon crawler with procedural levels.
Roguelike
A playbook for roguelikes — the turn engine, procedural dungeons, field-of-view, permadeath, and run economy. This is a compositional skill: it orchestrates procedural generation, tilemaps, save handling, and AI into a run-based game. It does not re-teach noise/RNG or tilemap APIs; it defines the loop and the systems that make a run compelling.
When to use
- Use when building a turn-based, grid-based dungeon crawler where each death ends the run and the world is regenerated — a roguelike or "roguelite" (with meta-progression).
- Use when designing procedural dungeons, FOV/fog-of-war, permadeath stakes, or loot tables.
When not to use: real-time action with roguelike dressing → build the action genre
(platformer/fps-shooter) and layer procedural-gen. Deep stats/quests/dialogue without
permadeath → rpg. Open-world needs/crafting → survival-crafting.
What makes it a roguelike (design anchor)
The community reference is the Berlin Interpretation (RogueBasin, IRDC 2008): a set of "roguelikeness" factors, not a checklist. The high-value ones are the design targets: random environment generation, permadeath, turn-based, grid-based, non-modal (all actions in one mode), complexity (many item/monster interactions), resource management, hack-and-slash, and exploration & discovery. Lean into these to feel roguelike; pick which to keep deliberately. "Roguelite" usually relaxes permadeath with meta-progression.
Core loop
Take a turn (move / fight / use) → the world resolves its turn → see new state → descend / loot / survive → die and restart with a fresh dungeon. Replayability comes from the world changing each run, not the player memorizing a fixed layout.
Must-have systems
- Turn scheduler — energy/initiative system so fast actors act more often (Pattern 2).
- Grid map + movement — tile coordinates; bump-to-attack; blocked/walkable queries.
- Procedural dungeon generator — rooms + corridors, or BSP/cellular; guarantee connectivity.
- Field of view + explored memory — what's visible now vs. seen-before (Pattern 3 / refs).
- Combat + entities — HP, attack/defense, status; monsters obey the same rules as the player.
- Loot + drop tables — weighted, depth-scaled item/monster spawning (refs).
- Permadeath + (optional) meta-progression — wipe the run; persist only unlocks/score.
- Message log + clear UI — the player reasons from text/state; surface numbers and events.
Design knobs
| Knob | Effect | Notes |
|------|--------|-------|
| Dungeon size / room count | run length, density | Scale with depth. |
| Connectivity guarantee | no unreachable rooms | Always verify reachability after generation. |
| Monster density / depth curve | difficulty ramp | Spawn by depth-weighted table. |
| Loot rarity weights | power variance | Rarer = bigger swing; identify adds discovery. |
| FOV radius / lighting | tension, information | Smaller radius = scarier, slower. |
| Resource scarcity (food/HP/ammo) | pressure to descend | Core tension lever in classic RLs. |
| Permadeath vs meta-progression | run stakes vs. retention | Roguelite softens the wall. |
| Identification / unknowns | exploration value | Unidentified items reward experimentation. |
| Seedable RNG | daily runs, debugging | Always allow a fixed seed (see procedural-gen). |
Patterns
1. Deterministic, seedable run RNG
# Pseudocode. One seeded RNG per run makes dungeons reproducible (daily runs, bug repro).
run_seed = chosen_seed or random_seed()
rng = Rng(run_seed) # use your engine's seedable RNG, not global random
dungeon = generate_dungeon(rng, depth) # same seed + depth => same dungeon
# Persist run_seed in the save so a crash can resume the same world (see save-systems).
2. Energy-based turn scheduler (speeds differ)
# Pseudocode. Each actor gains energy each tick and acts when it has enough.
# Faster actors gain more per tick, so they act more often — no fixed "player then enemies".
TURN_COST = 100
def next_actor(actors):
while True:
for a in actors: # stable order avoids ties favoring one side
a.energy += a.speed # e.g. speed 100 = normal, 150 = hasted
if a.energy >= TURN_COST:
a.energy -= TURN_COST
return a # this actor takes exactly one action now
3. Field of view + explored memory
# Pseudocode. Recompute visibility from the player each time they move.
visible = compute_fov(map, player.pos, radius=8) # symmetric shadowcasting (see refs)
for cell in visible:
explored.add(cell) # remember it forever (dim "fog of war")
# Render: visible -> lit; explored-but-not-visible -> dim; never-seen -> hidden.
Use a proven FOV algorithm (recursive shadowcasting or symmetric shadowcasting). Do not roll a naive raycast-per-cell — it produces asymmetric, "blinking" vision. See refs.
Pitfalls / failure modes
- Disconnected dungeons → rooms the player can't reach. Always run a connectivity/flood-fill pass and carve corridors until every walkable cell is reachable.
- Naive FOV → vision that flickers or is asymmetric (you see them, they don't see you). Use shadowcasting; test symmetry.
- Real-time loop pretending to be turn-based → input races and double-moves. Resolve one discrete turn at a time; queue input.
- Flat difficulty → no descent pressure. Scale monsters/loot by depth and keep resources scarce.
- Permadeath that wipes meta-unlocks → frustration. Separate run state (wiped) from
profile state (unlocks, scores) when saving (see
save-systems). - Save-scumming a "permadeath" game → delete or invalidate the run save on load if you want true permadeath; keep only the profile.
- Unreadable state → the player can't plan. Show HP, turn results, and a message log.
Composition (build it from these skills)
- Generation:
procedural-gen(noise, seeded RNG, dungeon/room algorithms) — the engine of replayability. - Map rendering:
godot-tilemap/unity-tilemap-2dfor the grid;level-designfor set-piece rooms/vaults. - Enemies:
game-aifor monster decision-making (often simple on a grid: seek/flee/patrol). - Persistence:
save-systemsfor run-resume, profile/meta-progression, and true permadeath wipes. - Scripting/data:
godot-resources/unity-scriptableobjectsto define items, monsters, and drop tables as data. - UI:
godot-ui-controlfor the message log, inventory, and HUD. - Feel:
game-feelfor hit/death juice — screen shake and hit-stop that sell impacts on a turn-based grid.
References
- For dungeon-generation algorithms (rooms-and-corridors, BSP, cellular automata, connectivity),
FOV (shadowcasting), and weighted loot/spawn tables, read
references/generation-fov-loot.md.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
