Your first useful session in Dashpop
Create a distinctive playable with your agent, discover its own Editor, and leave with one change you want to keep.
Find a guide.
Search game design, playtesting, and Editor workflows for the part of your game you’re working on.
56 guides
Give your agent feedback it can use
Describe the experience, preserve choices you love, and give your agent a change you can judge by playing.
Shape a world with its own creative controls
Navigate your game’s Editor, adjust real content, inspect its artwork, and return to Play to judge the result.
Understand the change behind the game
Use the Dashpop Editor’s Code and Tools views to connect visible behavior to the project and operations that create it.
Play the change you mean to judge
Use Play, restart, screen previews, and actual device checks to give a Dashpop game a useful playtest.
Keep your creative choices and a way back
Keep your game’s source, artwork, and creative choices together. Use saved edits and undo to explore changes in the Dashpop Editor.
Meet the Dashpop Game Engine
Understand the agent-native engine that brings a playable game, its own Editor, and your creative choices together.
Create a game with your agent
Build a creative partnership around a playable result, useful controls, specific feedback, and choices you want to preserve.
Unity prefabs and triggers: make a collectible that behaves
Build a reusable Unity collectible, understand prefab overrides and trigger events, and test repeated contact, duplicate instances, and restart.
Three.js: take a scene from spinning cube to small game
Plan a small Three.js game with input, state, timing, pickup rules, glTF assets, restart, and browser checks. A practical workshop beyond the first render.
What makes a game worth playing?
Learn to design for curiosity, discovery, and mastery. Play a pattern experiment, examine a courier game, and write a testable promise for your own game.
Give the player a decision worth making
Design meaningful choices with goals, tradeoffs, readable consequences, and uncertainty. Test route decisions and repair dominant or arbitrary options.
Small rules, surprising games
Understand how game rules interact, how feedback loops change a game over time, and how to prototype an economy without mistaking a simulation for player evidence.
Teach the game without a wall of instructions
Design a first level that introduces, varies, and combines ideas. Learn about readable cues, safe practice, difficulty, recovery, and testing whether players understand.
Build the smallest thing that can teach you something
Choose the right game prototype for your question, set a useful scope, separate design evidence from technical evidence, and write a practical experiment brief.
Watch a player. Change your mind. Make a better game.
Run a useful first playtest, separate observation from interpretation, diagnose design problems, and compare revisions without coaching players toward your preferred answer.
See your game through a different lens
Use Jesse Schell’s approach to inspect a game from several perspectives. Diagnose a courier junction and turn competing ideas into a small design experiment.
Make an action matter beyond the click
Explore meaningful play through an interactive two-delivery puzzle. Separate clear feedback from consequences that carry into later decisions.
Build a ladder of discoveries
Apply Raph Koster’s learning perspective to an original sequence puzzle. Build levels that let knowledge transfer instead of only increasing pressure.
Tune the space between intention and motion
Explore acceleration and drag in a step-by-step movement sandbox inspired by Steve Swink’s Game Feel. Compare readable control with visual polish.
Give your game room to breathe
Sketch a six-beat pacing curve, compare pressure and recovery, and turn the drawing into testable level changes informed by Jesse Schell’s interest curves.
Turn a hunch into a useful playtest
Build a focused playtest plan using Tracy Fullerton’s iterative approach. Match a prototype to a question and choose evidence that could change your mind.
Crossy Road: the fine art of not going yet
A Crossy Road game-design deep dive into timing, safe spaces, readable hazards, character collecting, and small-team scope. Includes an original playable traffic experiment.
Block Blast: that fits. But should it go there?
A Block Blast game-design analysis of spatial planning, piece order, satisfying clears, and fair puzzle generation. Play an original packing puzzle with undo and a worked solution.
Flappy Bird: one button, almost no spare attention
A Flappy Bird game-design analysis of timing, readable failure, tiny goals, and the limits of learning from a viral hit. Includes an original playable timing experiment.
Balatro: the hand is only the beginning
A Balatro game-design deep dive into scoring, Joker combinations, uncertain upgrades, and building a strategy from what a run gives you. Includes an interactive scoring experiment.
Vampire Survivors: take away aiming, give movement more work
A Vampire Survivors design analysis of automatic attacks, positioning, experience pickups, upgrade choices, and power growth. Includes an interactive movement experiment.
Celeste: hard jumps, generous controls
A Celeste game-design case study about coyote time, jump buffering, readable failure, and the difference between precision and punishment. Includes an interactive timing-window experiment.
Baba Is You: the rules are objects in the room
A Baba Is You design deep dive into movable rules, readable consequences, puzzle constraints, undo, and testing surprising solutions. Includes an original rule-changing experiment.
Use Blender with AI models through MCP
Connect a compatible AI client to Blender through MCP, choose Astra, Fable, or another model, and work from scene inspection to a tested game asset.
Develop a game with GPT-6 Astra
A practical plan for making games with GPT-6 Astra: choose an engine, write a brief, test changes, and keep a working project.
Astra vs Fable for game development: how to choose
Compare GPT-6 Astra and Claude Fable 5.1 on your game project with repeatable tasks for creation, debugging, revisions, cost, and play.
Can Astra make 3D game characters?
Understand character images, 3D meshes, rigs, animation, and engine integration before choosing an Astra and Blender workflow.
Astra + Roblox Studio: build a small experience
Plan an Astra-assisted Roblox workflow with Luau scripts, explicit script placement, server-owned game rules, and multiplayer testing.
Astra + Unity: get from scripts to a playable scene
Plan a Unity game workflow with Astra, including C# scripts, scene references, prefabs, input settings, and focused debugging.
From Blender asset to game engine: check the handoff
A practical asset handoff guide covering scale, orientation, materials, collisions, animation, and reimport in your game engine.
How to make a game with AI
Start with a playable rule, write a useful brief, test the result, and revise your game without losing the version that worked.
I have a game idea. Where do I start?
Turn a game idea or design document into a first playable prototype by choosing an action, a consequence, and a question to test.
Write a game brief an AI assistant can use
A plain-language game prompt worksheet with examples for mechanics, controls, feedback, visual direction, and useful revision requests.
Make a game without coding experience
Compare visual tools, templates, AI assistance, and learning a little code. Choose a first project you can understand and change.
Finished the tutorial. Now make your own game.
A practical exercise for escaping game-development tutorial hell by changing a known mechanic, predicting the result, and finishing a small original loop.
Design a small puzzle game with AI assistance
Build a puzzle around a meaningful decision, define move order and end states, and test a small board before adding progression.
Make a platformer that feels fair
Plan a first platformer around a readable route, useful jump tests, checkpoints, and clear feedback before adding more levels.
Design a fruit-merge game without mystery rules
Define merge order, collision behavior, spawn rules, and overflow for a small physics puzzle, then test the awkward cases.
AI wrote the game code. Why does it not work?
Debug AI-generated game code by separating build errors, scene setup, state bugs, and design problems. Keep repairs small and reproducible.
Make your game art look like one world
Create a small art-direction sheet and check palette, shape, perspective, light, and readability before producing more game assets.
Playtest your first game without coaching everyone
Run a small playtest, observe confusion and choices, ask useful questions, and turn feedback into one clear revision.
Browser game or native mobile game?
Understand the difference between playing on a phone, exporting a game, hosting a browser build, and releasing a native app.
Design touch controls that leave room for the game
Plan and test mobile game controls for simultaneous input, thumb coverage, release behavior, visual feedback, and readable play areas.
Improve game feel without adding another system
Tune response, anticipation, contact, and feedback in a small game. Compare changes on a fixed play route rather than adding effects blindly.
Paper-prototype a game before opening an engine
Test turn order, choices, and resource rules with paper pieces. Learn what paper can answer and when you need a digital prototype.
Change your game without losing the version that worked
Keep recoverable game revisions, record what a change is meant to improve, and verify that source, scenes, assets, and restart behavior stay together.
Make games with Claude Fable 5.1: plan the work
Use Claude Fable 5.1 for game-development tasks with clear project context, focused revisions, and evidence from the running game.
What does it cost to make a game with AI?
Estimate an AI game-development session by separating access, model usage, asset production, repairs, and human time.
Scope a game jam project you can actually finish
Plan a small game jam around one playable loop, early builds, clear ownership, and a cut list that protects the core idea.
Edit a game scene, then play the difference
Use Sunleaf Sprint to explore how moving platforms changes a playable route, then apply the lesson to your own game.