How to build a UE5 Fall Guys-style game in 4 days using only free AI

Building a 3D game in Unreal Engine 5 usually means a lot of time, skills, and money. But it’s now possible to get surprisingly far using only free AI tools—no paid models, no asset packs, and no coding from scratch.

This guide walks through how a simple Fall Guys–style platformer was built in just a few days using free AI for concept art, 3D models, animation, and game logic. You’ll see what tools were used, what actually worked, and where you still need some manual effort.

Project overview: a Fall Guys-style platformer

The goal was to recreate a lightweight version of a Fall Guys-style obstacle course: a cute character running through a colorful level full of rotating platforms, moving obstacles, and chaotic ragdoll falls.

The constraints were strict:

• Use only free AI tools (no paid credits, no subscriptions).

• Create all core assets: images, 3D props, character, animations, and Blueprints logic.

• End up with a fully playable level inside Unreal Engine 5.

The final result: a working UE5 level with custom characters, animated movement, ragdoll hits, AI-controlled NPCs, checkpoints, and multiple obstacle props—built mostly with free AI plus some manual setup.

Step 1: concept art with Gemini

The first step was concepting the visual style: characters and props. For this, a free image model in Google Gemini was used.

Gemini handled two main tasks:

• Character concepts – two simple, stylized creatures inspired by Fall Guys, but with a unique look.

• Prop concepts – obstacles and level elements like rotating platforms, bumpers, and other playful shapes.

In total, 26 prop concepts were generated while using only about 23% of the weekly free quota. That’s important: Gemini’s free tier has limits, but they’re generous enough for a small game if you prompt carefully and iterate instead of spamming generations.

Key tips for this stage:

• Stick to a simple, cohesive style (low detail, bold colors) so later 3D generation is easier.

• Reuse shapes and motifs so props feel like part of the same world.

Step 2: generating 3D models with Hunyuan 3D Studio

Once the 2D concepts were ready, the next step was turning them into 3D models. For this, Hunyuan 3D Studio was used—the free version still allows around 20 generations.

Hunyuan handled several important tasks in one place:

• Low-poly mesh generation – ideal for stylized, game-ready assets.

• UV unwrapping – automatically prepares the model for texturing.

• Basic texturing – applies simple materials that fit the cartoony style.

Because the chosen style was very simple, Hunyuan could produce clean, optimized meshes with minimal issues. For more complex, high-detail assets, it’s better to break objects into parts and assemble them later, but for this project, one-shot low-poly generation was enough.

If you ever move beyond strictly free tools, there are much more advanced 3D generators—Tripod’s Smart Mesh P2 and Smart UV, for example, are mentioned as best-in-class for low-poly and high-poly models. But for this challenge, Hunyuan covered everything at zero cost.

Step 3: rigging the character (manual)

Character rigging—the process of adding a skeleton so a model can be animated—was done manually. Because the character was extremely simple, this only took about 10 minutes.

Why not use AI here? Automatic rigging tools exist, but for a basic bean-shaped character, manual rigging is often faster and more reliable. The real challenge wasn’t the rig—it was the animations.

Step 4: testing AI models for animation

The plan was to use AI to generate animation logic and help control Blender and Unreal via tools and scripts. Several models were tested before finding one that worked well enough.

Trying GPT-6 Luna via CLI

The first attempt used GPT-6 Luna through a command-line interface (CLI), integrated into a local workspace with MCP (Model Context Protocol) tools for Blender and Unreal Engine.

This setup had a big advantage: running everything from the terminal made it easier to connect to local tools and scripts. However, the animation results were disappointing—stiff, low-quality motions that weren’t good enough for in-game use.

Trying Gemini 1.5 Flash

Next, a free Gemini model (Gemini 1.5 Flash) was tested for animation guidance. This produced better results than GPT-6 Luna, but still not at the level needed for smooth, game-ready movement. The animations looked rough and would stand out in a polished UE5 environment.

Finding a sweet spot with DeepSeek V4.1 Free on OpenCode

The breakthrough came from an unexpected place: OpenCode, a platform that offers multiple AI models, including a free tier of DeepSeek V4.1 (labeled as a free version, but effectively DeepSeek 4.1).

DeepSeek was accessed directly inside the existing workspace, which already had MCP connectors for Blender and Unreal. That meant the model could:

• Locate Blender and Unreal projects.

• Generate and edit scripts for animation and game logic.

• Work with tools in a more agent-like way, instead of just chatting in a browser.

The result: surprisingly good character animations. For this stylized character, the walk, run, and idle cycles were smooth and dynamic—good enough that they felt comparable to what a strong frontier model like Opus 5.5 might produce in a similar setup.

If you’re interested in how different frontier models compare on practical tasks, it’s worth checking experiments like this side-by-side build test of Fable 5 and Opus 4.8.

Step 5: setting up the Unreal Engine 5 project

With the models and animations ready, it was time to move into Unreal Engine 5. The project used the Blueprint system (no C++ required), and DeepSeek helped write and adjust many of the graph setups.

The process looked like this:

• Create a new UE5 project using Blueprints.

• Replace the default mannequin with the custom character mesh and skeleton.

• Hook up animations so the character could walk, run, and jump.

This wasn’t completely smooth. Early attempts led to odd behavior—like the character floating or jumping without a proper walk cycle. With a few rounds of prompting and corrections, DeepSeek eventually produced a working setup where the character could run around the level convincingly.

Step 6: building obstacle Blueprints with AI

Next came the interactive props: rotating platforms and other obstacles that define the gameplay.

For example, a rotating platform Blueprint was created with this logic:

• Only the top part of the platform rotates.

• Rotation speed is adjustable via exposed variables.

• The platform continuously spins during gameplay.

DeepSeek wrote most of the Blueprint logic, while manual Unreal knowledge helped fix small issues and fine-tune behavior. This hybrid approach—AI for the heavy lifting, human for debugging and polish—is very similar to how many people now use AI coding tools day-to-day. If you like this style of collaboration, you’ll probably also enjoy workflows like those described in these Claude co-work skills.

Step 7: adding ragdoll and recovery animations

A Fall Guys-style game needs one thing above all: hilarious falls. To get this effect, a ragdoll system was added.

The setup worked like this:

• When the character is hit by certain obstacles, it switches from normal animation to a physics-driven ragdoll state.

• After a short time, a stand-up animation plays so the character can recover and keep running.

DeepSeek helped configure both the ragdoll behavior and the stand-up transition. The stand-up animation, in particular, looked surprisingly natural—sometimes even rotating the character first before standing, which added to the charm.

The end result was a set of falls and recoveries that arguably looked even more satisfying than the original Fall Guys, especially given that everything was done with free tools.

Step 8: dealing with free-tier limitations

Using only free AI tools comes with a big trade-off: rate limits.

DeepSeek’s free tier on OpenCode would occasionally hit a usage cap, returning messages like “free usage exceeded.” In practice, this meant:

• Work sessions had to be broken up—after heavy use, it was often necessary to wait around six hours for limits to reset.

• Trying to create multiple OpenCode accounts didn’t help much, since usage seems to be tracked by IP or similar signals.

This is the main reason the whole project took about seven days instead of four. With unlimited access or starting on DeepSeek from day one (instead of testing weaker models first), the same work could realistically be done in around four days of focused effort.

On the upside, total usage was still modest: about 13 million tokens in DeepSeek’s own calculation—far less than the billions consumed in earlier experiments with high-end models like Opus 5.5.

Step 9: assembling the level by hand

Once all props and logic Blueprints were ready, it was time to build the actual level.

Here, AI was less helpful. Current free models struggle with designing large, interesting 3D spaces with good flow and pacing. So the level was assembled manually:

• All AI-generated props were placed by hand in the UE5 editor.

• Obstacles were arranged into a full obstacle course.

• Playtesting was used to tweak spacing, difficulty, and timing.

This layout work took about 2 hours and 40 minutes—very reasonable for a simple single-level prototype. AI still helped with smaller tasks and fixes, but the main composition and “feel” of the level came from manual design.

Step 10: adding NPCs, checkpoints, and final polish

To make the level feel alive, AI-controlled NPCs were added so players could run the course alongside other characters.

This step surfaced a few issues:

• Missing or incorrect colliders on some props.

• No checkpoints—players always respawned at the very start.

• Pathfinding quirks that caused NPCs to get stuck or behave strangely.

Using Unreal’s debug tools and some prior engine experience, these problems were identified and then fixed with DeepSeek’s help. The AI wrote and adjusted the logic for:

• Checkpoint systems so players respawn at the last reached point.

• Better collision and trigger setups.

• Basic NPC behavior, even if they still act a bit “dumb” and often get smacked by obstacles.

After a final overnight iteration and some tweaks, the game was fully playable: you could run the course, get knocked into ragdoll, recover, race NPCs, and reach the end.

What this experiment proves (and what it doesn’t)

This project shows that, today, you can:

• Design a visual style with free image models.

• Generate low-poly 3D assets with free 3D tools.

• Use a strong free LLM (DeepSeek V4.1 Free) to script animations, Blueprints, and tooling workflows.

• Ship a simple, but complete, UE5 level without spending any money.

However, there are clear limitations:

• Free tiers slow you down with rate limits and cooldowns.

• AI still needs guidance—you’ll move much faster if you already understand Unreal basics, debugging, and 3D workflows.

• Level design remains human-driven—AI can help with pieces, but not yet with full, fun, well-paced levels.

Tools used in this free UE5 workflow

Here’s a quick recap of the core tools involved:

• Google Gemini (image) – for character and prop concept art.

• Hunyuan 3D Studio – for low-poly 3D model generation, UVs, and basic texturing.

• Blender – for manual rigging and AI-assisted animation workflows.

• DeepSeek V4.1 Free on OpenCode – the main AI brain for scripting, animation support, and Unreal Blueprints.

• Unreal Engine 5 – the game engine used to assemble everything into a playable level.

How long does this really take?

In total, the project took about seven days from start to finish. But that includes time lost on weaker models and waiting for free-tier limits to reset.

Realistically, if you:

• Start with DeepSeek (or an equally strong free model) from day one, and

• Already know the basics of Unreal Engine and Blender,

you could recreate a similar game in around four focused days of work.

Can you repeat this yourself?

Yes. Every tool mentioned here either has a free tier or is completely free to install and use. The main things you’ll need are:

• Patience with free-tier limits.

• Basic understanding of Unreal Engine Blueprints.

• Willingness to iterate with AI instead of expecting perfect results on the first try.

If you’re comfortable letting AI handle most of the scripting and logic while you focus on decisions, testing, and layout, this kind of workflow is absolutely within reach.

As AI tools and agents improve, expect more of this pipeline—from concept to level design—to become even more automated, while you focus on creativity, taste, and game feel.