Godot 4.5 Threaded Loader vs Construct 3 Tick Groups for Floor Transitions - 2026

The player clears a room. The screen fades. For 400–900 ms nothing moves—or worse, input still fires while half the next floor exists. In May 2026 bug reports, that moment is the #1 roguelite fest-demo killer on both Godot 4.5 and Construct 3 ships, and the fixes sound nothing alike.

Godot teams reach for ResourceLoader.load_threaded_request and floor epochs. Construct teams reach for tick group order and layout transition discipline. Same player pain, different failure physics.

This Programming & Technical comparison is the cross-engine map the Construct save playbook and RNG tutorial forward-linked but did not yet publish. It is not another WASM memory ceiling essay and not a fourth Steam metadata checklist. Read the deep dives after you pick your lane: Godot threaded loader only, Construct event-sheet freeze challenge.

Who this is for and what you get

Time: ~45 minutes to read; 90 minutes to implement first fixes in your engine.
Prerequisites: One playable floor loop; for Construct, RNG seed ledger; for Godot, Godot 4.5 project.

Why this matters now (H2 2026)

1. Roguelite floor granularity — Rooms, not worlds; transitions happen every 60–120 seconds in fest demos. Hitch frequency beats hitch duration in refund psychology.
2. Cross-engine teams — Artists prototype in Construct, programmers port spikes to Godot (or reverse). Mis-translated fixes cause double work.
3. Construct NW.js + Godot Steam — Both target October 2026 Next Fest; both need proof artifacts beside BUILD_RECEIPT.
4. Save semver coupling — Construct save migration and Godot floor_index keys must agree with transition timing—loads and saves are one system.
5. Phaser third lane — Chunk streaming solves tile memory, not sheet order—triangulate instead of arguing engines on Twitter.

Direct answer: Godot removes main-thread load hitches with threaded requests + epoch guards; Construct removes logic-order and layout races with frozen tick groups + transition gates. You need both concepts if you maintain multi-engine ports.

The failure modes (same symptom, different root)

Concept mapping — epochs vs tick groups

Epoch is time discipline for async work. Tick group order is time discipline for synchronous events. Porting teams that only copy Godot loaders into Construct without freezing groups still fail.

Godot lane — threaded loader summary (not a full duplicate)

Full code lives in Godot threaded ResourceLoader guide. Comparative essentials:

Coordinator checklist

1. Increment floor_epoch on every portal trigger (including death restart).
2. load_threaded_request for PackedScene paths—never load() in transition _ready.
3. Poll statuses in _process; cap concurrent requests (4–8).
4. Instantiate only when all required paths report loaded and epoch matches.
5. Free previous floor root before adding new root (avoid double physics).
6. Web export: run hosting smoke tests—threading presets differ from desktop.

Godot anti-patterns

Minimal epoch guard (reference)

func _on_portal_entered() -> void:
    floor_epoch += 1
    var ep := floor_epoch
    _queue_floor_assets(next_floor_id, ep)
    # poll until complete or ep != floor_epoch → abort

Construct lane — tick groups summary

Full week discipline lives in 7-day event-sheet order freeze. Comparative essentials:

Group order template

Document in rng_seed_ledger.json:

"tick_group_order": ["RunRNG", "WorldSim", "Combat", "UI", "FX"]

Layout transition gate pattern

1. On door clicked → set transition_active = 1; disable Combat group.
2. Start fade (UI group).
3. On fade complete → Go to layout next floor.
4. On start of layout → reset spawners; set layout_ready = 1; enable Combat.
5. Clear transition_active.

Construct anti-pattern: Spawning enemies on Every tick during fade—reads as “game broke” in streams.

Construct vs browser refresh

Replay case study shows refresh ≠ layout change—but group order still must match ledger or replay diverges.

Side-by-side decision matrix

Hybrid studios: Prove each engine with its native pattern—do not paste GDScript structure into event sheets verbatim.

Proof table — comparative acceptance tests

Run engine-specific columns—do not average scores across engines.

floor_transition_receipt_v1.json (cross-engine)

{
  "receipt_type": "floor_transition",
  "version": "1.0.0",
  "engine": "godot_4.5 | construct_3",
  "build_id": "fest-2026-05-22",
  "godot": {
    "threaded_loader": true,
    "epoch_guard": true,
    "max_concurrent_loads": 6
  },
  "construct": {
    "tick_group_order_frozen": true,
    "ledger_path": "rng_seed_ledger.json",
    "layout_gate": true
  },
  "tests_passed": [1, 2, 3, 4, 5, 6, 7, 8],
  "notes": ""
}

Store under release-evidence/floor-transition/ beside release evidence taxonomy.

Beginner path — pick one engine this week

If you use Godot

1. Read threaded loader guide sections “Coordinator” and “Epoch”.
2. Replace one load() call in your portal flow.
3. Add floor_epoch global.
4. Run proof tests #1–#2.

If you use Construct

1. Complete RNG seed ledger evening.
2. Screenshot event sheet group order → paste into ledger.
3. Add layout gate pattern above.
4. Run proof tests #1 and #3.

Do not attempt both engines in one week unless you enjoy two half-fixed pipelines.

Developer path — porting and fest ops

Godot → Construct port checklist

Construct → Godot port checklist

Fest branch promotion gate

Before promoting demo branch:

• [ ] Floor transition receipt tests 1–8 green
• [ ] Wednesday demo smoke golden path includes two floor changes
• [ ] Playtest tools forms include build_id + floor_index
• [ ] Save migration semver matches Construct playbook if applicable

Phaser third lane (when neither engine fits)

Compare concepts, do not merge codebases.

Debugging playbook — 30-minute triage

Tooling cross-links

• 16 Construct debugging tools — ledger, refresh protocol
• 5-day crash log challenge — attach floor transition logs
• itch HTML5 demo scope — browser SKU limits affect Construct more often

Store and marketing (floor transitions are player-facing)

Unreadable loading text is not this post—but pixel font pass matters if your loading UI uses micro type during transitions.

Trailers that cut on black frames between floors train wrong expectations—sync with trailer frame audit.

Telemetry you can log without inventing metrics

Fest teams do not need a analytics SaaS to debug transitions—log counts locally:

Export last 50 transitions in a JSONL next to crash logs for crash log challenge. Do not publish fabricated “saved 40% load time” percentages in store copy—partners spot fake perf claims.

Worked example — Godot hitch traced to stale epoch

Symptom: Skipping a portal quickly spawns mini-boss assets from previous floor.
Profiler: Threaded loads complete after player already left.
Fix: On portal enter, increment epoch; in poll handler, if ep != floor_epoch: return before instantiate().
Verification: Test #1 twenty skips—zero orphan bosses.
Time: ~40 minutes for solo programmer.

Worked example — Construct hitch traced to FX group

Symptom: Fade plays but damage numbers still tick.
Sheet audit: Combat runs before UI during layout change.
Fix: Reorder groups to template; move damage to Combat; lock Combat until layout_ready.
Verification: Ledger screenshot matches engine; Test #3 pass.
Time: ~25 minutes for designer + 10 minutes programmer confirm globals reset.

Memory vs hitch (do not conflate)

Teams that only optimize WASM while ignoring tick order still fail Construct demos; teams that only freeze sheets while synchronous load() remain in Godot still hitch.

AI-assisted code warning

LLMs love generating load() in _ready (Godot) and Every tick spawns (Construct). Human review must enforce epoch and group discipline—see ChatGPT + Claude build log for review culture, not engine specifics.

90-minute paired studio workshop (two engineers)

Output: shared release-evidence/floor-transition/README.md linking both subfolders.

Release checklist — floor transitions before October fest

Publish build_id only when both sides agree test #5 passes on the same fest laptop if you ship dual SKUs (itch + Steam).

When to escalate to a deeper single-engine guide

This comparison stays the routing page; implementation depth intentionally lives in those URLs so we do not duplicate five hundred lines of GDScript or event-sheet screenshots here.

Outbound authority

• Godot docs: ResourceLoader threaded
• Construct manual: Event sheets

Key takeaways

• H2 2026 floor transitions are the roguelite bottleneck on Godot and Construct.
• Godot fix: threaded loads + floor epoch — see deep guide.
• Construct fix: tick group order + layout gates — see freeze challenge.
• Same symptom ≠ same root cause—use the failure mode table.
• floor_transition_receipt_v1.json works for both engines.
• Pair with save semver and RNG ledger—not isolated performance tuning.
• Phaser adds chunk discipline as a third lane.
• Fest promotion needs rapid-skip test #1 on real hardware.
• This post is comparative programming, not WASM OOM or store metadata.
• Engine war is less useful than epoch vs group order vocabulary.

FAQ

Which engine is “better” for roguelites?
Neither—maturity of your team’s discipline matters more than logo.

Can I use threaded loading in Construct?
No native equivalent—reduce per-layout cost and gate groups.

Does epoch replace save migration semver?
No—pair with save migration playbook.

We only ship itch HTML5 Construct—skip NW.js?
Still run layout gates; refresh bugs differ from NW.js but group order still applies.

Godot web export hitches only in browser?
Check threading preset and WASM playbook—distinct from desktop threaded path.

How does this relate to event sheet freeze week?
Freeze week is Construct implementation; this article explains why beside Godot.

Should multiplayer roguelites use the same patterns?
Epoch and group order still help local sim; netcode adds authority layer—not covered here.

What about Unity Addressables?
Same epoch idea as Godot; compare mentally, implement per Unity docs—out of scope but analogous.

Conclusion

Players do not care which engine you chose—they care that the door feels instant and fair. Godot 4.5 earns that with threaded ResourceLoader work guarded by epochs. Construct 3 earns it with tick group order frozen in a ledger and layout transitions that never spawn combat mid-fade.

Use this comparison to translate fixes across teams, file one floor transition receipt, and drill proof test #1 (twenty rapid skips) before October 2026 fest traffic. Then dive the engine-specific guides linked above—implementation depth lives there on purpose.

Next reads: RNG seed ledger tutorial, Construct save migration, Godot threaded loader.