Skip to content
Skills Library
Programming · Planning

engine-selection

/engine-selection

Selects game engines and frameworks by platform, genre, and architecture (full canvas shell vs hybrid DOM shell + guest viewport). Covers Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, Ink, Twine. Use when choosing a stack or comparing runtimes before implementation.

Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Selects game engines and frameworks by platform, genre, and architecture (full canvas shell vs hybrid DOM shell + guest viewport). Covers Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, Ink, Twine. Use when choosing a stack or comparing runtimes before implementation.

Original author description

Selects game engines and frameworks by platform, genre, and architecture (full canvas shell vs hybrid DOM shell + guest viewport). Covers Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, Ink, Twine. Use when choosing a stack or comparing runtimes before implementation.

How it works

  1. Fit questions (ask first)
  2. Architecture patterns
  3. Web — decision tree
  4. Quick comparison (web & common exports)
  5. Non-web defaults (see also platform skills)
  6. Anti-patterns
  7. When to Use
  8. Limitations
Original SKILL.md headings · 105 lines, 701 words
SKILL.md preview
---
name: engine-selection
description: >-
  Selects game engines and frameworks by platform, genre, and architecture
  (full canvas shell vs hybrid DOM shell + guest viewport). Covers Phaser,
  PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, Ink, Twine.
  Use when choosing a stack or comparing runtimes before implementation.
risk: safe
source: self
date_added: "2026-07-17"
---

# Engine selection

> Pick tools that match **delivery target**, **interaction model**, and **team constraints**. Engines serve the game type — not the reverse.

---

## Fit questions (ask first)

1. **Platform:** Web, mobile, PC, console, VR?
2. **Primary loop:** Action/physics, turn-based, narrative branch, management/UI, hybrid?
3. **Presentation:** Full-screen canvas, DOM/UI chrome, or both?
4. **Toolchain:** No-build / ESM OK, or bundler + editor OK?
5. **Authoring:** Code-only, or designers need Twine/Ink/Godot/Unity editors?

---

## Architecture patterns

| Pattern | When | Notes |
|---------|------|-------|
| **Full engine shell** | Game *is* the canvas/scene | Phaser, Godot, Unity, Kaplay as app root |
| **Renderer + custom logic** | You want draw power, own gameplay | PixiJS, Three.js + your systems |
| **Hybrid shell + guest** | Dense UI/text + occasional skill-checks | DOM/app shell; mount canvas engines in modals/viewports only |
| **Narrative runtime** | Branching prose is the product | Ink, Twine; host chrome separately |
| **Content-as-data** | Levels/events authored as packs | JSON/YAML + thin loader; engine optional |

---

## Web — decision tree

```
What type of game?
│
├── Mostly DOM / panels / forms / text UI
│   ├── + small arcade/spatial challenges
│   │     └── Hybrid: custom shell + guest
│   │         Raw Canvas/WebGL → Kaplay → Phaser → PixiJS
│   └── + branching story
│         └── Ink (inkjs) or Twine export → host in DOM
│
├── Full-screen 2D game
│   ├── Full gameplay features (scenes, physics, input)
│   │     └── Phaser 4  (or Kaplay if you want lighter/faster prototype)
│   └── Mostly rendering / custom systems
│         └── PixiJS 8  (or Raw Canvas/WebGL if tiny scope)
│
└── Full-screen 3D game
    ├── Full engine / physics / XR
    │     └── Babylon.js
    └── Rendering-focused / lighter
          └── Three.js
```

---

## Quick comparison (web & common exports)

| Tool | Type | Best for | Watch-outs |
|------|------|----------|------------|
| **Raw Canvas / WebGL** | 2D/low-level | Tiny games, learning, no framework tax | You own everything |
| **Kaplay** (ex-Kaboom) | 2D toolkit | Fast prototypes, jam games | Less “full product” structure than Phaser |
| **Phaser 4** | 2D engine | Complete 2D features | Heavier; often bundled |
| **PixiJS 8** | 2D renderer | Performance, custom game code | Not a full gameplay framework alone |
| **Three.js** | 3D renderer | Visuals, lightweight 3D | You add gameplay systems |
| **Babylon.js** | 3D engine | Fuller 3D + XR | Heavier than Three for simple scenes |
| **Ink + inkjs** | Narrative | Complex branching prose | Weak for real-time multi-entity sims |
| **Twine / Twison / TweeJS** | Narrative | Educator-friendly branches | Export/host glue; not a physics engine |
| **Godot 4** | Full engine | 2D/3D indie, open source | Web export iteration cost |
| **Unity** | Full engine | Large teams, multi-platform | Heavy for simple web UI games |

Editor-first web shells (**Construct**, **GDevelop**) fit visual prototyping; weaker when you need versioned code-first content pipelines.

---

## Non-web defaults (see also platform skills)

| Target | Lean toward |
|--------|-------------|
| PC indie / open source | Godot 4 |
| PC large team / multi-platform | Unity |
| Mobile | See `game-development/mobile-games` (touch, stores, battery) |
| VR/AR | See `game-development/vr-ar` (+ Babylon/Three on web) |

---

## Anti-patterns

| Don't | Do |
|-------|-----|
| Choose Unity/Godot for a form-heavy browser tool | Prefer DOM/hybrid |
| Force Ink to run real-time concurrent simulations | Use narrative tools for branches; custom/sim code for clocks & entities |
| Use Phaser as “the whole app” when the surrounding UI is HTML | Prefer a hybrid guest viewport |
| Optimize for WebGPU on day one | Ship WebGL; add WebGPU + fallback when needed |

## When to Use

Use when choosing or comparing game engines/frameworks before implementation, especially for hybrid DOM+canvas or narrative-first products.

## Limitations

- Does not replace platform skills (`game-development/web-games`, `game-development/pc-games`, …).
- Final choice still depends on team skill and shipping constraints.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

Versions

RepositoryScoreLicence
This page · FrancoStino/opencode-skills-collection100MIT
sickn33/agentic-awesome-skills100MIT

Database snapshot: 13.11.2026 · package version 040447f115e5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100game-development
    Game development orchestrator. Routes by platform, dimension, and engine fit (web 2D/3D, hybrid DOM+canvas, narrative tools). Use when starting or structuring a game project, choosing frameworks, or picking among Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, or Ink/Twine.
  • 100game-development
    Game development orchestrator. Routes by platform, dimension, and engine fit (web 2D/3D, hybrid DOM+canvas, narrative tools). Use when starting or structuring a game project, choosing frameworks, or picking among Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js, Godot, Unity, or Ink/Twine.
  • 100web-games
    Web browser game development. Framework selection (Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js), hybrid DOM+canvas, WebGPU, optimization, PWA, audio unlock. Use when building HTML5/WebGL/WebGPU games or choosing a browser runtime.
  • 100web-games
    Web browser game development. Framework selection (Phaser, PixiJS, Kaplay, Canvas/WebGL, Three.js, Babylon.js), hybrid DOM+canvas, WebGPU, optimization, PWA, audio unlock. Use when building HTML5/WebGL/WebGPU games or choosing a browser runtime.
  • 95game-development
    Game development with Unity, Unreal Engine, and Godot. Use when building games, implementing game mechanics, physics, AI, or working with game engines.
  • 100game-web2d-specialist
    Builds 2D browser games with Phaser 4 (primary), PixiJS 8, Kaplay, Excalibur or LittleJS: framework choice, Phaser scenes, Arcade or Matter physics, Tiled/LDtk tilemaps, atlases, pixel-art scaling, Phaser 3 to 4 migration and Playwright checks. Use for "Phaser", "PixiJS",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.