Towns is one of the clearest warnings from the early era of selling unfinished indie games.
It was a city-building and management game with RPG elements. It reached players while still unfinished, sold a large number of copies, and became part of the broader conversation about alpha funding and what would later become normal through Steam Early Access.
Then development was abandoned.
That outcome created a painful question for developers and players: what exactly does a buyer purchase when they pay for an unfinished game?
The Short Version
Towns shows that early sales do not guarantee a finished product.
The major failure points were:
- selling an unfinished game without a durable completion plan
- relying on continued revenue to support development
- developer burnout
- unclear player expectations
- the reputational damage caused by abandonment
For indie developers, the core lesson is that Early Access is a commitment, not just a funding mechanism.
What Happened
Towns launched on Steam before the formal Early Access program became what it is today. It was one of the early Greenlight successes and attracted players interested in simulation, management, and colony-style systems.
Public reporting from Game Developer described the game as having sold more than 200,000 copies and generated more than $2 million in gross revenue. Reporting also noted that development was abandoned after sales fell short of what the team needed, with burnout affecting the original development path.
Players reacted negatively because many had supported the game while it was still incomplete. Some expected their purchase to help fund continued development. When the project stopped, the purchase felt less like early access to a growing game and more like a broken agreement.
That is the central tension of unfinished game sales.
The developer may see the purchase as access to the current build. The player may see it as a vote for the future finished game.
If those expectations differ, conflict is almost guaranteed.
Why It Went Wrong
The problem was not simply that Towns made money and still failed. Gross revenue is not the same as sustainable production capacity.
An indie game can sell well enough to look successful from the outside while still failing internally because of:
- platform fees
- taxes
- refunds
- contractor costs
- support workload
- technical debt
- burnout
- revenue decline after the initial sales burst
- underestimated remaining scope
Early revenue can also create a false sense of security. A strong initial wave may hide the fact that the game still needs many months or years of development.
If the team has not defined what “finished” means, every new sale increases the number of people waiting for an answer.
That pressure can become heavier than the original development work.
The Failure Pattern
The Towns pattern is unfinished-product dependency.
It often follows this path:
- A promising unfinished game attracts early buyers.
- Sales provide money and validation.
- The team continues building while supporting players.
- The remaining scope is larger than expected.
- Sales slow down.
- Burnout and maintenance pressure increase.
- The team cannot justify or sustain continued development.
- Players feel abandoned.
The key risk is dependency on future sales.
If the project only works when new buyers keep arriving, the game is financially fragile. Early Access can delay that problem, but it does not remove it.
What Indie Developers Can Learn
Before selling an unfinished game, define the minimum complete product.
That definition should not be vague. It should include:
- core loop
- save/load reliability
- content baseline
- UI completeness
- performance targets
- tutorial or onboarding
- known missing features
- support plan
- refund and communication expectations
Players do not need a perfect game in Early Access. They do need to know what kind of project they are joining.
If the game might stop development without reaching a fuller version, say that plainly. That may reduce sales, but it prevents the most damaging mismatch.
The healthiest Early Access projects treat revenue as runway, not proof of success. The work is still unfinished until the team ships a version that can stand on its own.
Practical Checklist
Before launching in Early Access, ask:
- Is the current build fun enough without future promises?
- Can players understand what is missing?
- Is the version 1.0 scope written down?
- Can the team finish 1.0 if sales are lower than expected?
- How often will updates ship?
- What happens if a key developer burns out?
- What support burden will current buyers create?
- Are you selling a game or selling hope?
If the answer is mostly hope, wait.
Final Takeaway
Towns shows that Early Access can turn a development problem into a trust problem.
Selling early can help a game survive, but it also increases responsibility. Every buyer becomes part of the project’s public history.
For indie developers, the safest approach is to enter Early Access only when the current build has value, the path to 1.0 is realistic, and the team can keep communicating even when the money and motivation become harder.
Further Reading
- Game Developer: Alpha-funded Steam game Towns abandoned by devs
- TechSpot: Developers abandon unfinished Steam title and the 200,000 gamers that bought it
Keep Reading
Follow the engineering thread
Get the next practical Birdor note, or browse the archive for related systems, tooling, and architecture work.