Stream the Latest Episode
Available now on YouTube, Apple and Spotify. See the episode transcript at the top of this page, and a summary at the bottom.
Brought to You By
• Formation — Level up your career and compensation with Formation.
• WorkOS — The modern identity platform for B2B SaaS
• Vanta — Automate compliance and simplify security with Vanta.
—
In This Episode
In today’s episode of The Pragmatic Engineer, I’m joined by Jonas Tyroller, one of the developers behind Thronefall. Thronefall is a minimalist indie strategy game that blends tower defense and kingdom-building, now available on Steam. Developed by just two developers, it sold 1M copies in the first year of its launch: quite the hit for a game priced at $12.99!
Jonas takes us through the journey of creating Thronefall from start to finish, offering insights into the world of indie game development. We explore:
Why indie developers often skip traditional testing and how they find bugs
The developer workflow using Unity, C# and Blender
The two types of prototypes game developers build
Why Jonas spent months building game prototypes in 1-2 days
How Jonas uses ChatGPT to build games
Jonas’s tips on making games that sell
And more!
If you enjoy playing games, or one day perhaps could see yourself building your own game: this episode is for you.
Takeaways
My biggest takeaways from this episode:
It takes a lot of different skills to be a successful indie game developer. Jonas balances design, development, creating music, thinking about marketability, creating YouTube videos to share process (and get traction), building prototypes — just to name a few activities.
Graph theory can be surprisingly useful at times! Jonas used the A* pathfinding algorithm with this game: and fought a lot at making pathfinding “feel right.” It’s a good example on how computer science theory can become useful in various situations.
Engineering best practices don’t apply to most indie games. Jonas was almost embarrassed to admit they don’t do code reviews, don’t write unit tests and that the code quality could be better. However, indie games are built to ship once: so why overdo it? By all accounts, Thronefall is a smash success, with close to 1M sales. Code reviews and unit tests would have not helped this project with two experienced developers — though the lack of them might slow down larger projects!
To be good at building games: build a lot of games! Jonas made game development sound easy. However, I learned that he has 20 years of game development experience: having been building games since he was 9 years old! Here is a video about the close to hundred games he’s built. Most of them are very simple.
It’s easier than ever to build a game. Unity provides excellent tooling, and there are so many resources on how to build games — videos, tutorials, blogs, books. If you know how to code: you can build a simple game, the very least. We shared a tutorial: Building a simple game using Unity, if you want to get started.
The Pragmatic Engineer deepdives relevant for this episode
Timestamps
(00:00) Intro
(02:07) Building in Unity
(04:05) What the shader tool is used for
(08:44) How a Unity build is structured
(11:01) How game developers write and debug code
(16:21) Jonas’s Unity workflow
(18:13) Importing assets from Blender
(21:06) The size of Thronefall and how it can be so small
(24:04) Jonas’s thoughts on code review
(26:42) Why practices like code review and source control might not be relevant for all contexts
(30:40) How Jonas and Paul ensure the game is fun
(32:25) How Jonas and Paul used beta testing feedback to improve their game
(35:14) The mini-games in Thronefall and why they are so difficult
(38:14) The struggle to find the right level of difficulty for the game
(41:43) Porting to Nintendo Switch
(45:11) The prototypes Jonas and Paul made to get to Thronefall
(46:59) The challenge of finding something you want to build that will sell
(47:20) Jonas’s ideation process and how they figure out what to build
(49:35) How Thronefall evolved from a mini-game prototype
(51:50) How long you spend on prototyping
(52:30) A lesson in failing fast
(53:50) The gameplay prototype vs. the art prototype
(55:53) How Jonas and Paul distribute work
(57:35) Next steps after having the play prototype and art prototype
(59:36) How a launch on Steam works
(1:01:18) Why pathfinding was the most challenging part of building Thronefall
(1:08:40) Gen AI tools for building indie games
(1:09:50) How Jonas uses ChatGPT for editing code and as a translator
(1:13:25) The pros and cons of being an indie developer
(1:15:32) Jonas’s advice for software engineers looking to get into indie game development
(1:19:32) What to look for in a game design school
(1:22:46) How luck figures into success and Jonas’s tips for building a game that sells
(1:26:32) Rapid fire round
A summary of the conversation
Game Development Philosophy and Process
Finding a balance between personal interest and marketability: a key challenge for indie game developers. Finding something that will sell is difficult enough on its own, but finding something that will sell that you also enjoy working on is very tricky. The approach is to make a lot of things that you can imagine working on that are interesting and then try to measure or guess how well they might do on the market. Then, focus on the most promising ideas.
“What do I want to create today?” After opening up Unity, this is how a typical enough day starts for Jonas. He comes up with a random idea that he finds interesting and “just” makes it.
Games can be made very quickly. This is especially true for simple prototypes without fancy graphics or menus. Polishing and getting to production quality takes the most time. Keep in mind that Jonas has created closer to a hundred small games before, though!
Unity + C#: the development stack Jonas uses.
Scenes: the backbone of the project structure. In Thronefall a scene is basically a level. Each scene contains objects with attached scripts that dictate their behavior. These scripts are MonoBehaviours that inherit from the mono behavior class and are attached to game objects. We covered these concepts in the deepdive Building a Simple Game using Unity
Indie developers often write 'spaghetti code'. It’s also common enough to not write any unit tests. Jonas believes that unit tests are not critical for smaller indie games: but they do become more important at a larger scale.
QA process: “works on my machine,” beta testing and release. Modern game engines are a “godsend” for fewer bugs. If it “works on my machine” there’s a fair chance it works on everyone’s machine with robust game engines. For indie games, bugs are usually found through self-testing, beta testing, and ,finally by real players after the game is released.
Tools, Workflow, and Team Dynamics
Visual editing + code changes: this is the workflow Jonas follows. When building a new level, most of his time is spent moving things around in the Unity editor. He uses Blender for 3D modeling, where models are created and then integrated into Unity.
No code review. Not for a small indie game with two developers!
Push straight to main branch. And try to not break the game for the other dev!
Splitting the work: one Jonas focused more on the gameplay, and the other dev (Paul) did a lot more of the user interface. They also “cross-tested” each other’s work for functionality and the “fun factor.”
Listen to playtesters. Early playtesters reported that there were too few choices for the building upgrades: and so the team took this feedback and implemented more choices for upgrades.
Balancing levels is an art. Game devs are a lot better at playing the game than the average player. So they need to make levels to a difficulty that feels “stupid easy” for them – at least for early levels.
Strategy games are “snowbally.” This means that it is exponentially more difficult to recover from falling behind. To smooth this out, Jonas coded up enemies dropping gold in order to smooth out the economy curve. This made the game easier to balance because the amount of gold a player has at a given time is easier to predict.
Development and release
Prototyping: the first phase. The two devs created prototypes and mini-games, not spending more than 1-2 days on them. The time reserved for prototyping is scaled to the size of the project. For a two-year game, two months of prototyping could be a good rule-of-thumb. Prototypes help figure out what might sell well, and what the devs also enjoy working on.
Gameplay first. During the prototyping phase, gameplay is explored before visuals. Gameplay prototypes consist of simple shapes and colours and that visual prototypes are created after gameplay, and are composed of scenes without any logic or motion.
Major development challenge: pathfinding. For this game, Jonas spent a lot of time on this problem. How will units move “correctly?” How to ensure they don’t go through walls? The team bought a plugin from the Unity Asset Store using the A* pathfinding algorithm, and then customized it. Units don’t exactly move on nodes, so additional post-processing is required to ensure they are taking the straightest path between nodes.
ChatGPT: helpful for development. Jonas uses it to generate skeleton code, which is then filled in, and to translate shader code or answer questions on unfamiliar subjects.
Steam: a no-brainer. Steam is the go-to platform for indie developers, and Steam sales usually make up the vast majority of sales compared to other platforms.
The launch: not as fancy as you’d think! As per Jonas, the launch was surprisingly anticlimactic. He just pressed a button in the Steam backend.
The reality of being an indie developer
Bureaucracy: the dreaded part. Jonas hates bureaucracy the most in being an indie game developer. Things like filling out Steam forms, legal documents, and dealing with lawyers.
Advice: don’t build your own game engine! The single biggest advice Jonas has for a developer building their own game: do NOT turn it into building a game engine! It’s too tempting, but is a waste of effort for the most part.
“Bigger” games don’t necessarily sell better. Smaller games often have a better payoff-to-effort ratio because they are easier to make successful and the user experience should be prioritized before the engineering behind it.
University was helpful. Jonas says that it is possible to be self-taught in game development. However, for him, going to a game development college connected him with a valuable network of people. Both games that sold 1M+ copies he built with people he met at his university at HTW Berlin
How to succeed as an indie game developer? Find the correct overlap between something you enjoy and something that will also perform well in the market. It is not enough to just make a perfect game; it must be the right game. You also need to make a game for others, not just yourself!
Resources & Mentions
Where to find Jonas Tyroller:
• X: https://x.com/jonastyroller
• LinkedIn: https://www.linkedin.com/in/jonas-tyroller-213a63144/
• YouTube: https://www.youtube.com/c/JonasTyroller
Mentions during the episode:
• Thronefall on Steam: https://store.steampowered.com/app/2239150/Thronefall/
• Unity: https://unity.com/
• C Sharp: https://en.wikipedia.org/wiki/C_Sharp_(programming_language)#
• Blender: https://www.blender.org/
• Adopting Software Engineering Practices Across the Team: https://newsletter.pragmaticengineer.com/p/engineering-practices
• Warp Digital: https://warpdigital.com/
• Islanders on Steam: https://store.steampowered.com/app/1046030/ISLANDERS/
• Coatsink: https://coatsink.com/
• Will You Snail on Steam: https://store.steampowered.com/app/1115050/Will_You_Snail/
• No Gravity Games: https://nogravitygames.com/
• Miro: https://miro.com/
• A* algorithm: https://en.wikipedia.org/wiki/A*_search_algorithm
• ChatGPT: https://chatgpt.com/
• Claude: https://claude.ai
• Github Copilot: https://github.com/features/copilot
• Godot: https://godotengine.org/
• GameMaker: https://gamemaker.io/en
• Game Design program at Hochschule für Technik und Wirtschaft Berlin
University: https://gamedesign.htw-berlin.de/en/
• Opus Magnum on Steam: https://store.steampowered.com/app/558990/Opus_Magnum/
• Outer Wilds on Steam: https://store.steampowered.com/app/753640/Outer_Wilds/
• GAMEDEV: 10 Steps to Making Your First Game Successful: https://www.amazon.com/GAMEDEV-Steps-Making-First-Successful-ebook/dp/B08CBLXPB7
• Flow: The Psychology of Optimal Experience: https://www.amazon.com/Flow-Psychology-Experience-Perennial-Classics/dp/0061339202/
• Game Development Basics:
https://newsletter.pragmaticengineer.com/p/game-development-basics
• Building a Simple Game: https://newsletter.pragmaticengineer.com/p/building-a-simple-game
—
Production and marketing by Pen Name. For inquiries about sponsoring the podcast, email podcast@pragmaticengineer.com.
Share this post