Ben Reeves,Contributor

May 19, 2026

13 Min Read
A laptop in a neon room with the godot logo on it.
Photo by AndSus via Adobe Stock, logo via Godot

Editor's note: This story documents Ben's monthlong journey to make The Last Lamplighter. Be sure to play it over on Itch.io!

Every year, thousands of aspiring developers download Unreal or Unity with a dream. Weeks later, many of them quietly give up—but not for a lack of ambition. In many cases, they bump up against the friction of opaque tools, complex pipelines, and interfaces that look about as complex as a Boeing 747’s dashboard. Building games is less about having amazing ideas and more about wrestling systems into submission.

In other words, making games is hard.

For the last two decades, I’ve been looking for ways to navigate that friction from both sides of the curtain. First, as a journalist and Senior Editor at Game Informer, and more recently as a narrative designer at Firaxis Games, where I worked on titles like Marvel’s Midnight Suns and Sid Meier's Civilization VII.

I’ve seen how powerful (and complex) modern triple-A pipelines can be. They are massive machines built for teams of hundreds, not for one person sitting alone with an idea.

Related:Unreal Engine 6 will merge UE5 and UEFN into 'a single, unified engine'

What if we just need better tools?

For years, Godot has been building a quiet following. This dedicated group grew even more impassioned following the 2023 Unity Runtime Fee controversy, a widely criticized plan to charge developers per install.

As a result, Godot has become the engine of choice for many breakout indie hits, such as Slay the Spire II, The Case of the Golden Idol, and Cassette Beasts. Even industry giants are taking notice; Electronic Arts recently utilized a modified version of Godot to power the Portal map editor for Battlefield 6.

Part of the appeal is Godot’s sheer efficiency. The entire engine is a roughly 100-megabyte download, and it boots up faster than the time it takes to dig up the right project version. It’s lightweight, flexible, and isn't owned by a single corporation. In an era of shifting licensing fees and corporate gatekeeping, that last part matters more than ever.

This all raises an obvious question: Can something that small actually compete with engines backed by billion-dollar companies?

So, I decided to put Godot to the test. I’ve never touched the engine before, but I gave myself thirty days to build a game from scratch to find out whether this open-source upstart could actually deliver… or if I’d just end up crying in front of my monitor.

Day one: the game that doesn’t exist

Before I even download Godot, I know I need some help getting started, so I turn to an expert. René Habermann is the co-founder of Bippinbits and one of the creators behind the indie hit Dome Keeper. I called him to ask what advice he might have for someone starting out with Godot and looking to make a game in a short amount of time. Was Godot even the right choice? Habermann was quick to reaffirm my choice for reasons I hadn’t even considered.

Related:Video codecs are a nightmare for game developers, but there's no solution in sight

"Godot is incorruptible," Habermann says. "Like with every company, no matter how much you like the tool, if [their] company decides to sell or gets bought or whatever, someone can come in and make a shitty version of the tool or make an expensive version of the tool. Godot is not owned by anyone, so it's not possible for someone to come in and buy this. As long as the open source scene around that is healthy, Godot is incorruptible."

Great, but I still needed some tips on how to actually make a game. I ask him, thinking maybe he’d share advice about programming or workflow. Instead Habermann zeroed in on something deceptively simple.

"If I wanted to reliably make something decent in 30 days, I would try to scope it out in a way where I had a feeling I could make it in five days," Habermann says. "The less of a game designer people are, the more they tend to suggest settings instead of game ideas. So it's more like, 'I want this game where you are this knight, and you ride across a fantasy world, and you never dismount.' Like, that would be cool, but what's the game? What's actually the game inside there?"

Related:1000xResist creator: the game industry needs a universal video codec for FMV games

In other words: if the idea feels barely manageable, it’s already too big.

After talking with Habermann, I sat down with a notebook and tried to figure out what I could realistically build in thirty days. My mind drifted toward smaller ideas, classic hits and arcade staples that still manage to get their hooks into you. Stuff like Snake or Pac-Man. Then my brain took a hard turn toward the "clicker" genre.

Clicker games are deceptively simple. At their core, they’re about growth. They tickle the simple, lizard parts of our brains that like watching the numbers tick up. They’re also oddly hypnotic. Strip away the visuals, and you’re left with a pure feedback loop. That simplicity made them appealing for this project. But I’m a narrative designer by instinct, so I couldn’t help but wonder: What if the clicking actually mattered?

How do you give a clicker game a story? How do you make the player care about pressing the button? Maybe you’re trying to save someone’s life. But why? Maybe they were wounded in battle. Maybe you’re keeping their heart beating. Could I push that further? What if the person you’re saving is your enemy? Someone who invaded your home. Someone you were supposed to hate.

I started to picture the protagonist as a priestess, bound by her vows to preserve life, even after she encountered a soldier who had just tried to destroy her temple. By the end of the day, I had the seed of an idea, a small story about compassion and survival.

But I still hadn’t installed the engine.

Day two: the tutorial abyss

My first real day with Godot began with my watching a nine-hour YouTube tutorial. I looked up a walkthrough from the popular channel Clear Code, and for several hours, I dutifully followed along.

Then I got bored.

A screenshot of The Last Lamplighter's code in Godot.

Instead of finishing the tutorial, I opened the engine and started experimenting. I clicked through menus. Created scenes. Dragged nodes around. Broke things. Screamed in frustration. Googled solutions, read through message boards and documentation. Then I screamed some more. In case you don’t want to read the rest of this article, this was basically the next 28 days.

Aside from coding, I ran into another problem: I needed art. Habermann pointed me toward sites like Kenney.nl, OpenGameArt.org, and Itch.io as solid sources for free assets, so I started there. Before I knew it, the sun had already set on day two.

Day five: the first system

My first working mechanics appeared on days three through five. I built a heart-shaped UI element that slowly drained over time. I created a player character and a collision area so that when they walk near my wounded soldier, they can hit the spacebar to refill the heart icon.

I recognize that this kind of interface is a bit of a departure from most clickers, which rely on the rapid-fire mouse inputs. However, since my project felt more personal, I envisioned a character physically running around the screen to manage the chaos. The spacebar felt more tactile. It’s simple, but it works.

This means I’ve crossed an important psychological threshold: the moment when a collection of scripts and sprites begins to move around on a screen. It feels good. But I can’t shake the feeling that skipping large parts of my tutorials might come back to haunt me later. Still, in that moment, maintaining my momentum feels valuable.

Unsurprisingly, I soon ran headfirst into a classic Godot bug. Or rather, a classic Godot setting. I noticed that my health bar had mysteriously stopped draining. The code looked correct. I double-checked the math. It checked out. I triple-checked the math. Still, the bar refused to move. "This was working yesterday!" I kept yelling.

After hours of confusion, I discovered that the culprit was a small checkbox in my UI element labeled "Rounded." When enabled, the UI element ignored decimals and snapped all the values of my Heart UI to whole numbers. My script was subtracting tiny fractions each frame, but the node kept rounding them back to zero.

The code wasn’t broken. I just wasn’t experienced enough.

Thankfully, I was able to figure out the problem before the end of the day. Otherwise, I’m sure that problem would have left me tossing and turning all night. The whole event was also a reminder of something every developer learns eventually. Some bugs aren’t mistakes in logic; they’re a misunderstanding of the tools.

Day twelve: the mathematics of clicking

Nearing the middle of the experiment, my game has evolved into something resembling a clicker. Clicker games look simple, but they hide some surprisingly intricate math systems. Players click to generate resources. Resources buy upgrades. Upgrades generate more resources. Etc.

Soon you’re designing exponential curves and balancing your economic pacing. Even for a small prototype, tuning those numbers took longer than expected. I started looking at games like Cookie Clicker and Spaceplan just to see how they managed their scaling numbers.

And then I realized that I’d designed myself into a corner.

Clicker games thrive on escalation: you click, you earn, you buy, and then the buying does the clicking for you. It’s a beautiful, mindless machine. My "cute" narrative about loving your enemies seemed novel at the time, but it doesn't really play well with that design ethos. If you’re clicking to keep someone’s heart beating, once you’ve achieved a stable heartbeat, why keep clicking? But if all you ever do is click to maintain it, the loop becomes exhausting.

I thought maybe the narrative would fix this problem, but it just helped me realize how boring the game is. Right now, my gameplay loop is: click to get story… then click to get more story. This is just reading with extra steps. This isn’t going to hold someone’s interest for long.

A screenshot of The Last Lamplighter in Godot

So I added a second clicker element: a workbench. When the priestess moves over there they can do more clicking and slowly build up shards. What do shards do? Not sure yet, but I’m thinking maybe you can use them to build a new heart. Maybe that’s the answer. Players must keep the old heart alive long enough to construct a replacement. Meanwhile, the numbers still climb on a second UI system, feeding the same loop in a different form.

There’s a strange tension between tending to the soldier and building the machine that might save him. I’m starting to think the fun isn't in the clicking itself, but in juggling that balance. I’m hoping to recreate that low-level panic of trying to be in two places at once, the kind of fun you have playing something like Overcooked. Or, perhaps, I've just invented a whole new set of problems for next week.

Day twenty-one: chaos in the code

By the second half of the project, my codebase had become a tangled spiderweb. UI scripts were talking to gameplay scripts. Dialogue systems were firing signals. Auto-clickers were generating resources while characters delivered lines. Everything is speaking all at once, and some things were getting lost in the shuffle. This is because I built the thing ad hoc.

After Googling for solutions and asking around online, I began to understand that I needed a centralized controller, a kind of brain for the game that would coordinate all these systems. I needed a script that autoloaded at startup and managed everything. To experienced programmers, this is probably obvious. To me, it's a revelation, and I feel like I have to tear apart the project and rebuild it. I think the bill is finally coming due for all the time I "saved" skipping tutorials in week one.

Turns out, the technical debt wasn't just structural. At one point, I spent hours trying to hide a part of the UI until after a certain conversation, but my code didn’t seem to be playing well with a plug-in that I had installed called Dialogic, which handles most of my conversations. I kept getting an error that reads, "dialogic not declared in the current scope." I was losing my mind because the code worked perfectly in another scene.

The fix? I just needed to capitalize the 'D.' That was it. That was the whole bug.

Game development has a unique way of forcing humility.

Day thirty: a twenty-minute game

Near the end of the experiment, I played through my entire game from start to finish… it took twenty minutes. I had spent nearly thirty days building something that could be consumed over a lunch break. There’s something poetic about that. Also a little crushing.

But then I remembered that playtime isn't the only measure of value. The project worked, and I was growing in my skills as a developer. On the final day, I realized the glow areas I’d added to guide players toward each bench weren’t very clear signposts, especially since some of them first appear off-screen. To fix this, I decided to add a directional arrow above the player’s head. At first, it just pointed stubbornly at the center of the screen.

In week one, a bug like that might have stalled me for a day, or more if I’m being honest. I would have scrolled through forums in a blind panic. But now, I have a better sense of things when I look under the hood. I suspected a hierarchy issue, and I quickly found the parent Area2D for each bench was misaligned. Rebuilding the logic to point the arrow the right way only took a few minutes. The friction of game development hasn’t disappeared, but my ability to navigate it has improved. The arrow snapped into place, pointing exactly where it needed to go.

A screenshot from The Last Lamplighter. The player character says

Before logging off for the last day, I took a moment to look over the game. It was a short messy experience, but I was proud. The systems functioned. It told a story. It felt like a game. 

And most importantly, it was mine. For a solo developer learning a new engine, that was the biggest victory.

Day thirty-one and beyond: was this worth it?

Thirty days with Godot didn’t turn me into an indie studio. Making games is still hard; it’s messy, frustrating, and full of small mistakes that take hours to uncover. Godot didn’t magically simplify the laws of physics or the logic of code, but it did something more important: it made the process approachable.

There is a massive difference between a solo project and the complexity of a triple-A title. Engines like Unreal have a staggering amount of power, but for a solo creator that power can be paralyzing. If you’re too intimidated to start, the engine’s capabilities don’t matter. In that way, Godot lowers the barrier to entry.

During my time at Firaxis Games, I saw the scale of triple-A systems up close. Modern pipelines are built for specialists. As a narrative designer, I was only one part of a much larger machine; I wrote characters and stories that would pass through many hands before they became real.

Building my prototype in Godot felt different. It was more personal. My 30-day prototype isn’t a masterpiece. It’s uneven, held together with questionable logic and placeholder art. It’s a far cry from the polished precision of Marvel's Midnight Suns or Civilization VII. But I’m oddly thrilled knowing that every bug exists because I put it there.

Godot isn’t the magic wand I was hoping for. It won’t build the game for you. But if it’s the tool that finally gets you into the arena instead of watching from the stands, then it’s already done something remarkable.

About the Author

Ben Reeves

Contributor

Ben Reeves is a game designer and writer whose credits include Marvel’s Midnight Suns and Civilization VII. A former editor at Game Informer Magazine, he has spent two decades at the intersection of game development and journalism. He is currently available for narrative consulting and story architecture. You can find him on BlueSky at @benreeves.bsky.social.

Latest Podcasts