We Used Gemini 4 to Turn a Sketch Into a Playable Game. Here’s How You Can Too
We put Gemini 4 Argon to the test by turning a rough game sketch into a playable 2D platformer called Coin Quest. From uploading the drawing and writing our first prompt to testing controls, collecting coins and exporting the game, here's our hands on experience and how you can try it yourself.
Can Gemini 4 turn a simple drawing into a game you can actually play? We wanted to find out, so we tried a Gemini 4 sketch to game experiment using Canvas. We started with a rough drawing of a platformer called Coin Quest, uploaded it to Gemini and asked it to build a playable version. What followed was a surprisingly smooth first attempt, complete with jumping, coin collection, obstacles and a working finish screen.
What started as a simple drawing eventually became a game we could complete. Here’s how we went about it, including the exact prompt we used so you can try it with your own sketch.
Before We Started
We kept the setup simple. All we needed was access to Google Gemini, the Argon model, Canvas and an image of our game sketch.
We used a desktop browser because we wanted to test keyboard controls. There was no game engine to install and no separate coding environment to configure. Our plan was to see how far we could get inside Gemini itself before looking at the code or exporting anything.
Step 1: We Started With a Rough Game Sketch
The first decision was what kind of game to make. We could have tried something complicated, but that would have made it difficult to tell whether Gemini was following the drawing or simply inventing its own design. So we chose a basic 2D platformer with enough moving parts to make the experiment worthwhile.
We called it Coin Quest. The drawing had a stick-figure character standing at the starting point, four floating platforms leading towards the right, six coins to collect, a few spikes to avoid and a red flag marking the finish. We also added arrows and a small legend to make the layout easier to follow.
We didn’t spend time polishing the drawing. We wanted to know whether Gemini could work from something that looked like an early game idea, not a professionally prepared design. If you’re following along, you can draw something similar on paper or create a digital sketch. Just keep the objects clear enough to recognise and save the image as a PNG or JPG.
Step 2: We Opened Gemini and Enabled Canvas
With the sketch ready, we opened Gemini in our browser. We selected Argon from the model dropdown and enabled Canvas from the options below the prompt box.
We chose Canvas because we wanted a playable result, not just a response containing code. It provides a workspace where you can preview what Gemini builds and switch to the code when you want to inspect it.
Our Gemini workspace with Argon selected and Canvas enabled.
To follow the same process, open gemini.google.com, choose an available model that supports Canvas and select Canvas before uploading your image. We used Argon, so your result may look different if you choose another model.
Step 3: We Uploaded the Drawing
Next, we clicked the + icon beside the prompt box and attached our Coin Quest sketch. Once the image appeared in the message area, we checked that Canvas was still selected.
At this stage, we hadn’t asked Gemini to generate anything. We wanted it to use the sketch as the main reference, so we kept the image attached while preparing our instructions.
If you’re trying this yourself, upload your drawing in the same way and leave it attached to the prompt. That way, Gemini receives the visual layout and the gameplay requirements together.
Step 4: We Wrote One Prompt to Explain the Game
This was probably the most important decision in the experiment. Our sketch showed what the level should look like, but it couldn’t explain everything about how the game should work.
For example, we’d drawn six coins along the platforms, but nothing in the picture said that collecting them should increase a score. The spikes were intended to be dangerous, but Gemini wouldn’t necessarily know whether touching them should end the game, restart the level or simply reduce the player’s health.
We wanted the drawing to guide the design while the prompt explained the behaviour. So we wrote one set of instructions covering the layout, keyboard controls, jumping, collisions, scoring and finish condition.
Here’s the exact prompt we used
I have uploaded a hand-drawn sketch of a 2D platformer game called “Coin Quest”.
Your task is to turn this sketch into a fully playable browser game using Gemini Canvas.
Game requirements:
- Carefully analyse the uploaded sketch and recreate its level layout, including the starting position, floating platforms, coins, spikes and finish flag.
- Create a character that moves left and right using the arrow keys or A/D.
- Allow the character to jump using the Space key.
- Implement gravity, jumping physics and platform collision detection.
- Make coins collectible and display a live score counter.
- When the character touches a spike, restart the level.
- When the player reaches the finish flag, display a victory screen showing the final score.
- Add smooth animations, colourful graphics and a clean game interface.
- Include a restart button so the game can be played again.
Use the uploaded sketch as the primary reference. Do not redesign the level or add unrelated game mechanics.
Build the complete playable game and provide a working preview directly in Canvas.
Once everything was in place, we clicked Send. We deliberately didn’t split the request into several smaller prompts because we wanted to see what Gemini could produce in one attempt.
If you’re using your own drawing, you can adapt the game name, objects and controls, but we’d recommend being equally clear about how the game should behave. The sketch shows Gemini where things belong; the instructions explain what those things are supposed to do.
Step 5: The First Game Appeared in Canvas
When Gemini finished generating the project, we opened the preview to see what it had made. The result was recognisably Coin Quest. We could see the stick-figure character, floating platforms, six coins, spikes and the finish flag arranged along the same general path as our original sketch.
What we liked was that Gemini hadn’t turned the drawing into a completely different-looking game. The preview still had a sketchbook feel, with simple outlines and handwritten-style elements. It also included a coin counter showing 0/6, a Restart button and instructions for moving the character.
There was even a Sketch Hints toggle, which we hadn’t specifically asked Gemini to add.
The layout looked close to what we’d imagined, but appearance alone wasn’t enough to judge the result. We still needed to check whether the platforms, coins and obstacles behaved like parts of a real game.
Before testing your own version, compare the generated preview with your drawing. Make sure the important objects are present and that the player has a reasonable path from the starting point to the finish. If something essential is missing, you can ask Gemini to correct it before playing.
Step 6: We Started Playing and Testing the Controls
The first thing we did was the simplest thing a player could do, walk. The character could be moved left and right with the arrow keys and Space made him jump. Then we attempted landing on the first floating platform to determine if the collision detection was working.
Once we had confirmed that movement and jumping worked we started to collect coins. When the character touched them they were removed from the level and the counter increased. We walked across the platforms until we had collected five of the six coins.
If you’re following along, this is the point where you should test the controls rather than just look at the generated design. Try moving in both directions, jumping onto platforms and collecting objects. Watch whether the score updates correctly and whether your character lands where you’d expect.
We then wanted to check what happened when things went wrong. Instead of avoiding the spikes, we intentionally moved the character into them.
Gemini handled the collision as we’d requested. The character returned to the starting position, the coin counter reset to zero and a restart notification appeared.
This was a useful part of the test because it showed that the spikes weren’t simply decorative. The game recognised them as hazards and responded according to the rules we’d given it. In your own game, it’s worth trying a few things the player isn’t supposed to do. You’ll learn more about whether the mechanics actually work.
Step 7: We Played Through the Entire Level
After testing the obstacle, we restarted Coin Quest and tried to finish the level properly. This time, we focused on collecting all six coins and reaching the flag without touching the spikes.
We made our way across the platforms, collected the remaining coins and reached the end. The game displayed a Quest Complete screen showing 6/6 coins and 600 points.
This was the clearest indication that our initial prompt had worked. We had managed to move through the level, interact with its objects, trigger the failure condition and then reach the winning condition without having to ask Gemini to rewrite the game.
When you’re testing your own project, try to complete the full level rather than stopping after the first successful jump. It’s the easiest way to spot problems with scoring, obstacles or the finish condition that might not be obvious in the initial preview.
Step 8: We Checked the Code Behind the Game
After finishing the level, we switched from Preview to Code inside Canvas. We wanted to see what Gemini had generated to make everything work.
The project contained HTML, CSS and JavaScript, along with styling resources such as Tailwind CSS and Google Fonts. We hadn’t written or edited this code ourselves during the experiment. Our part had been preparing the visual reference, explaining the gameplay and testing the result.
You can open the Code tab in your own Canvas project to inspect what Gemini built. Even if you’re not familiar with programming, it’s useful to see that the playable result is backed by actual source code. If you’re curious about a particular feature, you can also ask Gemini to explain how it works.
If you’re interested in taking these experiments further, we also tried building a simple AI assistant with Make.com, where we connected an AI model to a working automation without developing a separate backend.
Step 9: We Downloaded the Game
The last thing we wanted to check was whether we could take the project outside Gemini Canvas.
We opened the Export menu in the upper-right corner of the workspace and found two options: Google Sites and Download code. We chose Download code and saved the generated project.
After downloading the files, we opened the game in our browser. The Coin Quest interface loaded with its familiar layout, platforms, coins, character and controls.
For us, this was a useful final step because we weren’t limited to viewing the game inside Gemini. We could also inspect and keep the generated files.
We had already tested the main gameplay mechanics inside Canvas. Although the exported interface opened successfully, we didn’t separately complete another full gameplay test in the downloaded version. If you’re planning to publish or share your game, we’d recommend doing that additional check.
What Did We Learn From the Experiment?
In retrospect, the biggest surprise was just how much Gemini got right on the first prompt. We were hoping it would get to a level that looked like our drawing, but we didn’t know if all the mechanics would work without a few fixes.
During testing, we had working character movement, jumping, coin collection, spike collisions, and the victory condition. One of our main requirements was that the game should keep the basic arrangement of our original sketch.
But there are limits to what this experiment tells us. Coin Quest was a short, one-level platformer. We did not test complex features like moving enemies, advanced physics, multiple levels or performance on different devices. More iteration would probably happen on a larger game.
One thing we’d definitely recommend is to be specific with the prompt. Our sketch provided the visual direction but the instructions detailed how the game should behave. Both of them had a big part in getting the result we wanted.
Final Thoughts
We started this experiment wondering whether Gemini 4 Argon could turn a rough game sketch into something playable. By the end, we’d created a small platformer, collected all six coins, tested the obstacles and completed the level with 600 points.
The interesting part was that we hadn’t written the game code ourselves, and we hadn’t needed to send correction prompts to make the basic mechanics work. We provided the idea, drawing and gameplay instructions, and Gemini produced the initial implementation.
Of course, this doesn’t mean every sketch will turn into a finished game on the first attempt. But for a simple prototype, our experience showed how useful a visual reference and a clear prompt can be.
If you’ve got a game idea scribbled somewhere in a notebook, try starting with a small level, uploading the drawing to Gemini and explaining what you want the player to do. Test the result, see what works and improve it from there.
That’s how our Coin Quest experiment started, and we ended up with something we could actually play.