u/ernestwisniewski

I’ve been working on a small 4X strategy game built with Flutter and Flame. It started mostly as an experiment and a way to learn Dart/Flutter more deeply, but the project has grown enough that I decided to make the code public.

Website: https://aonw.net
Devlog: https://ernest.dev
GitHub: https://github.com/ernestwisniewski

It’s still very much a work in progress, but I’m sharing it in case anyone is curious about game development with Flutter/Flame, project structure, or just wants to take a look.

Feedback, issues, and contributions are welcome.

Hey! Some time ago I mentioned here that I was working on a game in Flutter. Today I finally published the repo: Age of New Worlds.

I also write a bit about some of the design and technical decisions on my blog:
https://ernest.dev/

If anyone feels like taking a look, poking around, or telling me “I’d probably do this differently”, I’d really appreciate the feedback.

While waiting for Age of New Worlds to move through the publishing path for iOS, Steam, and Android, I tried a small experiment.

This time in Unity.

Not as a replacement for AoNW. More as a question:

>

A few hours later, I had the first slice of Peryhelium: a space 4X prototype about colonizing the Solar System, starting with the Moon, previewing locked planets, and rendering spherical hex maps with real planetary textures.

Hi everyone,

I’m looking for Android testers for my closed test of Age of New Worlds, a turn-based 4X strategy game built around hex maps, city founding, research, fog of war, AI opponents, and conquest.

Google Play link:

https://play.google.com/store/apps/details?id=aonw.net.game

If the Play Store link does not open for you yet, please use the tester opt-in link:

https://play.google.com/apps/testing/aonw.net.game

What I’d love feedback on:

- Does the game install and launch correctly?

- Any crashes, freezes, or broken screens?

- Is the UI readable on your device?

- Does the first match flow make sense?

- Any confusing controls or unclear actions?

The game currently focuses on single-player against AI and local hot-seat play. Online multiplayer is still in development, so I’m mainly testing the core strategy loop, stability, UI, and Android device compatibility.

If you test it, please leave your device model, Android version, and any issues you notice. I’m happy to return the favor and test your Android app as well.

Thanks!

Hi! In my spare time, I’m building Age of New Worlds, a turn-based hex 4X strategy game: https://aonw.net

The project is still in a very early stage, but the core gameplay loop is already playable. Next week I’m planning to release test builds for Android and Steam, with a public GitHub repo following shortly after.

I’m also writing about the development process, design decisions, and lessons learned in a devlog:

• My attempt to build a hex-based 4X strategy game with Flutter and Flame
• Building AI That Uses the Same Commands as the Player
• How I Built Multiplayer for a Turn-Based 4X Game with Flutter, Dart, WebSockets, and PostgreSQL
• Turning Game History Into Something You Can Actually Use
• Bringing a Flutter Game to the Web

Feedback is very welcome.

A strategy game is not only about making decisions.

It is also about understanding them later.

In Age of New Worlds, a turn can contain many tiny things: a scout discovers a new civilization, a city finishes production, a unit moves through fog of war, diplomacy changes slightly, a battle resolves, research progresses, and the player probably notices only half of it while thinking about the next move.

For a long time I could run the Flutter app. I could run the Dart server. I could start a database. I could test multiplayer locally. That was enough while everything lived on my machine.

But a public build changes the shape of the problem.

Suddenly the project needs a real URL, TLS certificates, a running backend, a database that survives restarts, a static web bundle, a homepage, health checks, version numbers, iOS archives, and one command that can push the whole thing without me reconstructing the release process from terminal history.

This post is about that part: how I containerized the backend, how I split the domains, how I deploy the web demo, and how make deploy-all became the release button for the project.

When I started building Age of New Worlds, I was thinking mostly about the native app.

Flutter gave me the UI layer. Flame gave me the game scene. Dart gave me a shared language for the client, the rules, the AI, and the server. That was already enough complexity for a solo project.

Then I wanted one more thing: a public web version.

When I started building multiplayer, I was not trying to bolt networking onto an existing single-player prototype at the last minute. A 4X game has a large world state, hidden information, turn submission, AI players, long reconnect windows, and plenty of tiny UI-only interactions that should never touch the server. I needed a multiplayer architecture that treated the server as the source of truth while still letting the Flutter client feel responsive. You can test it at https://aonw.net

After nearly two months of intensive Dart and Flutter learning, I’m finally releasing the first public playtest build of AoNW, my 4X strategy game.

You can try it here: https://aonw.net

AoNW

This is not a polished release. It is very much an unstable public test build for single player mode. Saves may break, progress may be lost, and weird things will definitely happen. I’m putting it out mainly so people can test the core mechanics, feel the game loop, and help me catch the rough edges early.

There is also a web version available, but please treat it as experimental. It runs significantly worse than the app build, especially on heavier maps or longer sessions. The web version exists mostly so people can quickly see the game without installing anything, but the native app is the better way to play and test right now.

What is already in the game:

• turn-based single-player gameplay
• hex map exploration
• fog of war
• cities and city founding
• production and population basics
• resources and yields
• unit movement and action flow
• workers and tile improvements
• research and technology progression
• basic combat
• objectives and victory direction
• AI turns / basic opponent behavior
• UI for map modes, help popups, action hints, and game flow

What still needs serious work:

• diplomacy
• artifacts and artifact victory flow
• game balance
• AI decision-making
• pacing
• UX polish
• performance, especially on web
• save stability
• a lot of “does this actually feel fun after 50 turns?” tuning

The goal right now is not to pretend this is finished. It isn’t. The goal is to get the foundations in front of real players and start learning from actual play instead of only testing in my own head.

I’m also preparing a technical post about getting the web version ready and containerizing the project for deployment. That part turned into its own adventure: Flutter web, Docker, server deployment, static hosting, domains, build automation, and the small chaos that happens when a solo project starts becoming a real thing.

• If you try it, I’d love feedback on the basics:
• Does the turn loop make sense?
• Do the actions feel understandable?
• Is the map readable?
• Where do you get confused?
• What breaks first?

This is the first public step for AoNW. It is unstable, incomplete, and probably a little too ambitious, but it is finally playable outside my machine, and that feels huge.

I’ve started a new series where I share my experiences developing Age of New Worlds - a hex-based 4X strategy game built with Flutter and Flame.

I’ll be writing about the technical challenges, game systems, rendering, architecture decisions, mobile strategy game development, and everything I learn along the way.