Godot

Godot is a free, open-source engine with an approachable 2D workflow and a quick HTML5 export cycle.

Quick-Start Steps#

Step 1: Set Up Your Godot Project#

Install Godot 4.x (the standard build, not .NET, since .NET web export support is limited) and build your game as usual (official docs). For the Minit Games feed, configure Project Settings > Display > Window for portrait:

• Width: 960
• Height: 1480
• Stretch mode: canvas_items
• Stretch aspect: expand

These pair with the export preset's Canvas Resize Policy (Step 3) to fill the Minit Games host's iframe at any device aspect ratio.

Step 2: Integrate Minit SDK#

Install the Minit Games SDK, a Godot addon that registers a Minit autoload with a small snake_case API.

Primary (once published): open AssetLib in the editor, search for "Minit Games SDK", and install. This copies the plugin into addons/minit/.

Manual fallback: copy the Minit-Games/minit-godot repo's addons/minit/ folder into your project's addons/ folder (plugin.cfg, plugin.gd, minit.gd).

Either way, enable the plugin to register the Minit autoload: Project > Project Settings > Plugins > Minit Games SDK > Enable.

No-editor / quick-try fallback:

Download the Minit SDK (minit.gd)

This is just the facade script (no plugin.gd, so nothing to enable); register the autoload manually instead: Project > Project Settings > Autoload, add the downloaded minit.gd, name it Minit.

With the Minit autoload registered, wire up the baseline lifecycle from any script:

extends Node2D

func _ready():
  # Call once your game has booted and is ready to be shown.
  # The host keeps the game hidden until this fires.
  Minit.loading_done()

func _on_game_over(score: int):
  # Call exactly once when the game ends. Higher score = better.
  Minit.report_result(score)

func _load_difficulty() -> String:
  # Read a mod config value from the URL query string, e.g. ?difficulty=hard
  return Minit.get_config_value("difficulty", "normal")

• Minit.report_result(): the one call every Game must make. Options and result handling: Reporting Results.
• Minit.loading_done(): optional; holds the host's reveal until your game is playable. Game Ready Signal.
• Minit.get_user_data() / report_result(score, { "user_data": ... }): optional per-player persistence. Saving User Data.
• Minit.get_config_value(key, default): reads mod config values off the URL query string; outside the host it returns default (editor/desktop) or reads the URL directly (standalone Web export). Declaring the keys: Config Values.

Step 3: Export for Web#

Install the HTML5 export templates (one-time setup), then Project > Export, create an HTML5 preset, and configure:

• Thread Support: OFF. A threaded build needs COOP/COEP cross-origin-isolation headers the Minit Games host iframe does not guarantee.
• PWA: OFF. Games run embedded in the host's iframe, not as an installable web app.
• Canvas Resize Policy: Adaptive. Paired with Step 1's stretch settings, this lets the exported canvas fill the host's iframe at any aspect ratio. Your game still has to draw into the revealed area. See Filling the frame.

Click Export. Godot produces a folder with index.html at the root plus supporting files (index.js, index.wasm, index.pck, asset sidecars).

Step 4: Upload to Creator Console#

Zip the exported folder's contents (with index.html at the ZIP root) and upload to the Creator Console.

Start from a template#

Instead of generating from nothing, clone the official starter template, with structure and SDK wiring already in place:

• minit-template-godot: engine project, SDK wired and simple example game mechanic

Minit Games-Specific Tips#

Touch Input#

Handle InputEventScreenTouch/InputEventScreenDrag rather than relying on mouse events. When developing on desktop, also accepting mouse clicks and a key press makes editor playtesting convenient.

Filling the frame (responsive layout)#

The expand stretch aspect never adds letterbox bars: Godot reveals extra viewport area on whichever axis is wider than your 960×1480 design size. Your game has to actually draw into that area, or it shows as an unpainted strip in the window's clear color. Two ways to handle it:

• Anchor your UI. Build HUD and menus from Control nodes with anchors/containers. A background ColorRect at Full Rect anchors guarantees the whole frame is painted.
• Read the live viewport size for anything drawn or placed manually. get_viewport_rect().size returns the actual (expanded) size each frame. Lay out backgrounds, ground, and world bounds against it, not the hardcoded 960/1480. Spawn off-screen objects at the live width.

Prefer a strict fixed-size design with bars? Use aspect keep instead of expand.

Bundle size#

A Godot 4 web export ships the entire engine as a WebAssembly binary: a multi-megabyte baseline (between Defold and Unity), with your .pck usually just kilobytes on top. It fits the platform bundle limits; compress textures in the .pck, and see the Godot docs for engine-side size tuning.

Best For: small to medium 2D Games with simple physics and straightforward mechanics (fast export cycle, approachable 2D workflow).

Common Pitfalls#

• Relying on localStorage: forbidden. Persist via Minit.get_user_data() / report_result(score, { "user_data": ... }). See Saving User Data.
• Opening the export from file://: browsers refuse to fetch the .wasm from a local file:// page. Serve the folder over HTTP to test locally, e.g. python -m http.server. Purely a local-testing gotcha: hosted games are served over HTTPS.