ArcadeForge Alpha

Ship joyful game loops faster — design, test, iterate

ArcadeForge is a compact studio toolkit that turns design intuition into playable builds. Rapid prototype levels, compose emergent mechanics, and measure player rhythm with built-in telemetry — without the overhead of heavy engines.

Built for designers, loved by players. Teams ship updates weekly with smaller risk.
ArcadeForge hero artwork: schematic level preview with neon tiles and HUD overlays

Play-first tooling

Fast iteration panels show live inputs and response curves so designers tune feel in minutes, not days.

Composable systems

Connect small mechanics into emergent combos, version them, and branch experiments with minimal friction.

Player lens

Lightweight telemetry and session heatmaps reveal what keeps players engaged across loops and levels.

Features that respect speed and craft

A palette of prefabs, event-driven scripting, layered audio cues and visual stubs make it simple to bootstrap a playable loop and iterate while players test via live sessions.

  • Prefab behaviors and drag anchors
  • Session replay with bookmarks
  • Telemetry funnels and retention heatmaps
Feature preview: level editor with prefab list and runtime preview

Start a prototype now

Create a sandbox, invite a tester, and iterate in minutes. No heavy installs required.

12×

Faster iteration for level tuning

89%

Tester retention within a single session

5m

Average prototype-to-playable time

From jam sessions to polished levels

ArcadeForge began as a living sketch between a designer and a developer who wanted to keep playtests alive during late nights. Rather than waiting on serialized builds, they needed tools that reflected how designers think: immediate, malleable, and anchored to player response. Over several prototypes the system grew into a compact set of tools: a modular level composer, event-driven hooks, simple telemetry and a lightweight sharing layer that makes it simple to invite a tester or iterate with a collaborator. Today the toolkit helps teams shorten the loop between idea and player feedback. Designers ship small changes, watch real sessions, and re-compose systems that work. The core idea is humility — keep mechanics small, test fast, listen to rhythm, then scale the parts that delight. This process reduces guesswork and makes production less costly, allowing teams to focus creative energy on moments players remember rather than engineering pipelines. Rapid iteration is not just about speed; it is about clarity, playfulness and designing a reliable path from intuition to finished interaction.

Story image: two designers prototyping with sticky notes and a tablet preview

What teams say

“We cut our iteration cycle in half. Playtests feel natural now — designers ship confident changes.”

— Lina R., Lead Designer

“Telemetry that actually helps. We stopped guessing why a level felt off and focused on what mattered.”

— Mateo V., Producer

Get in touch

Tell us about your project and we’ll suggest a quick onboarding flow.

Message sent