A little curiosity goes a long way
Developers & game makers
Plan, build and test browser and mobile games with practical examples and tool comparisons.
What brings you here?
Find your kind of fun
- Options & ideas
Check hosting permission before placing a game in an iframe
Learn how browser-game embeds work, what permission and hosting requirements to check, and how to test an iframe before publishing it.
- Options & ideas
Decide what you need to take out of the game maker
Compare playable links, project files, and builds, then verify what a game maker actually lets you export before choosing a workflow.
- Options & ideas
Find out whether you are extending a game or making a new branch
Learn how mods differ from remixes, what permissions and source files each needs, and how to check a project’s rules before changing it.
- Options & ideas
Match the tool to the game you want to finish
Compare visual editors, code-first tools, and AI-assisted makers by learning curve, project control, exports, and testing needs.
Make a game with AI
- Options & ideas
Treat AI output as an experiment inside the jam rules
Use an AI game prompt to explore a jam-sized mechanic while checking the host's current rules, ownership terms, and submission format.
- Options & ideas
Protect the time for testing by shrinking the scope
Plan a weekend-sized game jam experiment around one mechanic, a short test cycle, and the host's real submission requirements.
- Guide
Study a design decision by making it playable
Use short game design exercises to examine rules, player feedback, and scope through a prototype that can be tested and revised.
- Options & ideas
Keep the class activity focused and the product scope clear
Plan a teen game design activity with a paper brief, one testable mechanic, a public-safety check, and a clear classroom alternative.
- Guide
Show the thinking behind one playable decision
Build a focused public prototype that demonstrates one design choice, then document your process without implying source export or embedding.
- Options & ideas
Make the group agree on one testable game rule
Help a small group turn different ideas into one playable brief, then test the result without confusing discussion with collaboration tools.
- Guide
Prototype one story moment before building a long branch map
Test a story beat as a player decision, track one visible consequence, and see whether readers understand the emotional turn.
- Guide
Observe what players do before asking what they want
Share a playable build, ask neutral questions, and turn audience reactions into one focused revision rather than a feature poll.
- Guide
AI Game Prompts That Give a Game a Clear Shape
Write focused AI game prompts with a player action, goal, pressure and readable feedback, then use a simple playtest to decide what to change.
- Guide
How to Make a Game With AI From a Small Idea
Go from a rough idea to an AI-made game by narrowing the action, writing a testable prompt and refining the result through short play sessions.
- Options & ideas
Choose between a hosted prototype and an Android editor
Compare prompt-led mobile creation with an Android game editor, then choose a workflow that fits how much control you need.
- Guide
Use the extra screen space without skipping device tests
Use a tablet-sized workspace to draft a game idea, test touch or keyboard input, and choose an editor that matches your build goal.
- Guide
Choose the no-code workflow that matches your next step
Compare prompt-led creation with visual event editors, then test a no-code mobile game idea using a short, observable play loop.
For game developers
- Guide
AI Game Development Without Losing Design Control
Use AI as a development assistant for small games while keeping the core loop, code review and playtesting decisions in your hands.
- Guide
Browser Game Development: Start with the Runtime
Plan a small web game around input, rendering, state and browser behavior before choosing libraries or adding more systems.
- Guide
Prototype a Game’s Core Loop Before Expanding It
Build the smallest playable version of a game loop, then use focused tests to find whether its action and consequence are worth repeating.
- Guide
Scope a Small Game Around One Complete Experience
Keep a small game finishable by defining its core loop, content limit, must-have states and the features you will deliberately defer.
- Guide
Shape a Game Difficulty Curve One Demand at a Time
Raise challenge by changing readable demands gradually, and test whether players understand each new demand before adding another.
- Guide
Design Game Feedback That Explains Each Action
Make game feedback show what changed, why it changed and what the player can do next without covering the play area.
- Guide
Design a Restart Flow That Respects the Player’s Time
Make failure understandable and restarting easy to choose, while protecting players from accidental resets or lost progress.
- Guide
Teach a Game’s Controls Through the First Actions
Introduce controls and goals in a small sequence, then check whether players can act without reading a wall of instructions.
- Guide
Make Randomness Feel Fair in a Game
Choose what randomness controls, give players enough information to respond and test whether outcomes feel varied without seeming arbitrary.
- Guide
Write Scoring Rules Players Can Understand
Design a score that rewards the behavior your game values, explain bonuses clearly and check for strategies that overwhelm the intended play.
- Guide
Design a Win Condition That Players Can Recognize
Define what counts as success, communicate progress toward it and decide how edge cases resolve before building the final screen.
- Guide
Turn Game Design Constraints into Clear Choices
Use limits on controls, screen space, session length or production time to focus a game instead of adding features without a purpose.
- Guide
Make the drawn target and pointer test share one coordinate map
Convert pointer positions into a canvas game's world space so visible targets and clickable hit regions remain aligned after scaling.
- Guide
Clear input state when a key release is missed
Release held movement safely when focus or visibility changes, and test the blur, pause and restart paths that can leave game input stuck.
- Guide
Render each HUD value from authoritative game state
Keep score, lives and timers consistent by treating game state as the source of truth and rendering HUD values from one update path.
- Guide
Treat a seed as the input for a reproducible layout
Use a stored seed to recreate procedural game layouts, separate generation from validation, and keep a failing level easy to reproduce.
- Guide
Give listeners one owner and one lifetime
Stop repeated input and callbacks by giving each scene's event listeners a clear owner, setup boundary and teardown path.
- Guide
Migrate old save shapes deliberately
Add a versioned save envelope and explicit migrations so browser games can handle older local data after their save shape changes.
- Guide
Pool only objects with a clear reuse lifecycle
Decide whether a reusable object pool fits a browser game, and define activation, reset and capacity rules before pooling entities.
- Guide
Map atlas cells to source and destination rectangles
Keep sprite atlas frames aligned by defining source rectangles, trimming rules, pivots and loading checks in one rendering map.
- Guide
Advance the simulation in fixed-sized steps
Separate physics updates from rendering with a fixed simulation step, bounded catch-up work and tests for stalls and collisions.
- Guide
Check level data before it reaches the game loop
Reject malformed game levels before play by validating structure, numeric bounds, references and reachability with clear fallback behavior.
- Guide
Build touch input around clear intent
Plan touch interaction around browser gestures, readable feedback and deliberate pointer state so a game responds predictably on phones.
- Guide
Use one pointer model without losing input details
Model mouse, pen and touch through pointer events, while preserving capture, device identity and compatibility behavior in a game loop.
- Guide
Give keyboard input a clear contract
Make keyboard gameplay predictable by choosing semantic keys, handling press and release state, and avoiding conflicts with browser defaults.
- Guide
Test the hit area, not just the button art
Make game controls easier to hit by separating visual artwork from interactive bounds and checking size, spacing and overlap on touch devices.
- Guide
Resize the presentation while preserving the game model
Adapt a game surface to its container without tying simulation state to screen dimensions, and test the layout across changing viewports.
- Guide
Respond to rotation without losing input accuracy
Keep play readable when a device rotates by recalculating layout and input mapping without treating orientation as a game restart.
- Guide
Encode important states with more than hue
Use contrast and redundant visual cues so players can distinguish game states when hues are similar or unavailable to them.
- Guide
Reduce nonessential motion without hiding meaning
Use the reduced-motion preference to offer a calmer presentation while preserving essential game information and understandable feedback.
- Guide
Make game audio expected and adjustable
Give players control over game sound with clear mute and volume behavior, and handle browser autoplay restrictions without breaking feedback.
- Guide
Show where keyboard input will go
Make keyboard entry, menus and return paths predictable by giving the game a visible focus state and restoring focus after overlays close.
- Guide
Treat cancellation as a complete input path
End drags and held actions safely when the browser cancels a pointer, and avoid stuck controls after scrolling, rotation or interruptions.
- Guide
Test the interaction path on actual input devices
Build a small input test matrix that covers real touch, mouse, keyboard and orientation behavior instead of relying on one desktop session.
- Options & ideas
Decide whether the phone is the play target or the editor
Plan a game for phones, compare browser and native builds, and choose a practical first workflow before adding mobile-specific systems.
- Options & ideas
Use the engine for gameplay and Android tools for delivery
Choose an Android engine path, test on real device sizes, and prepare a signed build and Play Console listing without assuming one tool fits all.
- Options & ideas
Build for iPhone or iPad, then verify on Apple hardware
Compare native iOS game tools and cross-platform engines, test on simulator and device, then understand the App Store release sequence.
- Options & ideas
Make the release artifact and store submission agree
Turn a working phone game into a store-ready release with a build checklist, staged testing, platform metadata, and a reproducible handoff.
- Guide
Let portrait layout support the game’s main decision
Shape a portrait-first game around one clear playfield, readable status, and changing phone viewports before adding content or landscape support.
- Guide
Make the core action comfortable without hiding the game
Reduce one-thumb play to a workable action set, account for hand position and screen occlusion, then test the mechanic in realistic grips.
- Guide
Check the risky phone interactions before adding content
Run a phone-specific acceptance check for layout, touch, interruption, and restart behavior before investing in more levels or store packaging.
- Options & ideas
Compare the editor device with the player’s build
Compare mobile game tools by where the editor runs and what build it produces, then test the workflow that matches your phone-game goal.
- Guide
A game loop that stays predictable across displays
Structure browser game updates and drawing around animation frames without tying simulation speed to a player’s display refresh rate.
- Guide
Make movement depend on time, not frame count
Apply elapsed time to game motion, choose a safe catch-up policy, and test movement at different refresh rates and after stalls.
- Guide
Treat hidden tabs as a game state
Use page visibility changes to choose what pauses, what gets saved, and how a browser game resumes without a time jump.
- Guide
Make Canvas performance changes from evidence
Profile a 2D canvas game with repeatable scenes and reduce costly drawing work only after measuring where frames are spent.
- Guide
Make game loading feel clear and dependable
Plan an asset loading sequence that reports real progress, handles failures, and avoids decoding a large image during a critical frame.
- Guide
Choose a canvas pixel density deliberately
Balance canvas backing resolution, device pixel ratio, memory use, and drawing cost when a game must look clear across screens.
- Guide
Find memory that grows after a scene should end
Use repeatable play and cleanup checks to find retained game scenes, listeners, timers, and assets that accumulate over time.
- Guide
Use the simplest collision test that fits the shape
Pick a collision representation that fits your game, reduce unnecessary pair checks, and diagnose objects passing through obstacles.
- Guide
Make a resize a controlled layout transition
Keep game coordinates, canvas dimensions, and layout in sync when a player resizes a window or changes orientation.
- Guide
Let the player start sound intentionally
Design an audio start flow that handles autoplay blocking, delayed playback, mute choices, and sound tests across browsers.
- Guide
Plan for the graphics context to disappear
Detect a lost WebGL context, preserve game state separately from GPU objects, and test a deliberate renderer recovery path.
- Guide
Tell the player what the game is doing
Replace vague waiting states with clear phases, meaningful progress, retry choices, and a truthful transition into playable game state.
- Guide
Measure the player-visible problem before tuning
Build a repeatable performance test for browser games, separate frame symptoms from causes, and compare changes on matching scenes.
- Guide
Test the playable promise, not just the first screen
Build a focused test plan for an AI-generated game: check its central rule, controls, failure states and repeatability before polishing details.
- Guide
Evaluate whether the prototype proves its idea
Compare an AI game prototype with its intended experience using a compact rubric for clarity, control, challenge and recovery.
- Guide
Make every important prompt instruction testable
Translate a game idea into testable acceptance criteria with clear actions, outcomes, failure cases and a deliberately small first scope.
- Guide
Give another tester a reliable path to the failure
Turn a confusing game failure into a reproducible report by capturing the build, setup, exact inputs, expected result and observed result.
- Guide
Test the edge of each rule deliberately
Find edge-case failures by testing limits for movement, timing, screen edges, score counters and repeated input in a small browser game.
- Guide
Retest the working parts after every meaningful change
Protect a working game loop after revisions with a short regression checklist focused on mechanics, scoring, restart and nearby edge cases.
- Guide
Control the variables that make a game test repeatable
Control random values, time and starting conditions so game tests produce comparable outcomes and failures are easier to diagnose.
- Guide
Check the paths between game states
Map a browser game's start, play, pause, win and loss states, then test every transition and the inputs that should be ignored.
- Guide
Make persistence behavior intentional and testable
Verify what a browser game saves, what resets, and how it behaves when stored data is missing, stale or changed between sessions.
- Guide
Prioritize browser differences that affect play
Choose a practical browser test matrix for a small web game, focusing on input, rendering, viewport changes and the environments players use.
- Guide
Make each iteration answer one useful question
Improve an AI game prototype through short, evidence-led passes that preserve what works and change one testable problem at a time.
- Guide
Find the console message that explains the failure
Sort browser console messages by player impact, preserve the first useful error and investigate the action that triggered it.
- Guide
Validate generated content as part of the game
Review generated levels, dialogue and item descriptions against concrete content rules, playability checks and consistent feedback.