Unobserved: a side project to experiment with game development

Video games have been part of my relationship with computers from the very beginning. Before I knew what programming was, I was already fascinated by the idea that somebody could create a world, define its rules, and let other people explore it.

Over the years I ended up building all kinds of software, but I never worked professionally in game development. I do not think I ever will, either. I have no plans to change careers, start a studio, or turn this into something larger than it needs to be.

Even so, game development has always caught my attention.

There is something special about the mix of programming, design, art, sound, and systems. A game can start as a few objects moving on a screen and, little by little, become a place with its own logic. You press a key, something reacts, and suddenly those lines of code feel alive. It reminds me of what attracted me to computers in the first place: the possibility of creating something from nothing.

Unobserved was born from that curiosity. It is a side project for learning, experimenting, and enjoying the process without the pressure of turning it into a product or a business.

Open source · GPLsergi-io/unobservedUnobserved is open source under the GPL license. Browse or download the code on GitHub.View source

Play the prototype

You can play the current version of Unobserved directly below. Click inside the game to start, or open its itch.io page if you prefer to play it in a separate tab.

The idea is simple: you pilot a lone ship through a hostile galaxy while surviving enemy waves, avoiding asteroids and hidden threats, discovering planets, and improving the ship along the way. Every run is an attempt to travel a little farther and make better decisions with limited information.

There are weapons, shields, drones, missiles, artifacts, pickups, and different upgrades. You can reveal the map through the fog of war, reach distant planets, and colonize them with beacons. I wanted the combat to have an arcade feel, but also to make positioning, timing, and upgrade choices matter.

It is still an early and imperfect prototype. There are systems that need more work, numbers that need balancing, interfaces that will change, and plenty of things that can break. But that is precisely the point of the project.

When I work on software professionally, I usually have experience, context, and a reasonably clear idea of what I am doing. With game development I get to be a beginner again. I have to discover why movement does not feel right, why an enemy wave is boring or unfair, why an upgrade sounds interesting but does not change the way you play, or why a tiny visual detail can make an action much easier to understand.

It has also reminded me how interconnected everything is in a game. Changing the speed of a ship affects aiming. Changing the range of a weapon affects enemy behaviour. Adding a new artifact can make an existing upgrade useless. A small decision in one system can travel through the entire game.

What is behind Unobserved

Unobserved is built with Godot. It is the first game engine in which I have felt truly comfortable. I like its workflow, its editor, and the way it lets me concentrate on the game instead of spending my limited time fighting the tool. Most of the gameplay logic is written in GDScript and split into scenes and reusable systems: ships, enemies, projectiles, planets, pickups, explosions, and active artifacts each have their own responsibilities.

That scene-based structure has been especially useful as the prototype has grown. The Nuke, for example, is not simply a large explosion. It has an inventory item, an artifact script, a placement flow, a bomb scene, guided movement, an explosion scene, camera feedback, damage rules, fog-of-war integration, and its own shader. Wormhole Dash, Vortex, and the different beacons follow similar patterns, so new abilities can reuse parts of the same foundation instead of becoming isolated hacks.

Shaders are a large part of the visual identity. Godot’s canvas_item shaders power the procedural galaxy background, shields, invisibility, fog transitions, the energy around the level-up panel, planet surfaces, the Vortex, beacon scans, and several explosions. The Nuke is one of my favourite examples: its mushroom cloud is generated from procedural noise, radius masks, bloom, smoke, fissures, and a shock ring. GDScript drives parameters such as its progress, fade, and random seed at runtime, so every detonation evolves over time and looks slightly different.

The galaxy itself also moved from a static starfield to a procedural background with stars, nebula layers, asteroid detail, colour controls, and motion. Planets use dedicated scenes and shader-backed visuals for different kinds of worlds. For some of that work I used Pixel Planet Generator by Deep-Fold, an excellent set that gave the prototype much more visual variety while I explored what its final style might become.

Some systems are visual and mechanical at the same time. Fog of war is divided into 2 layers: space that has never been explored and space that was explored but is not currently visible. The minimap uses the same state, can represent multiple ships, and lets the player drag the camera around the universe like a small RTS map. Enemies, missiles, drones, pickups, planets, and effects all have to react consistently to what the player is allowed to see.

I also experimented with multiplayer much earlier than was probably sensible. Unobserved has a dedicated universe network controller and an authoritative-server approach: the server owns the real state and clients request actions. Ships, inventories, pickups, weapons, enemy destruction, progression, fog, game-over state, and restarts all needed some form of synchronisation. I tested the first version with up to 8 players. It is still experimental and not the main point of the public prototype, but it taught me how quickly multiplayer forces every system to have clearer ownership and boundaries.

Behind all of that is a very practical layer of debug tools. The panels visible in the screenshots let me add enemies, award XP, disable cooldowns, reveal fog, enable God Mode, inspect performance, and force a win. They are not pretty, but they shorten the distance between changing a value and understanding what it does. For a side project built in small pockets of time, that feedback loop is part of the technology too.

Much of the process does not look particularly glamorous. It involves debug panels, temporary graphics, values changing in real time, and many attempts that end up being discarded. The screenshots even show some of those tools. I quite like that because it is an honest picture of the project: this is not a finished game pretending to be perfect; it is something I am building to understand how games work.

I have used a small amount of generative AI during development, just as I use it in many of my current experiments. I am a father, I have a job and a family to support, and the time available for side projects is limited. For me, AI has been another tool for keeping momentum, not a replacement for the decisions, learning, and care behind the game.

Publishing the prototype on itch.io has been another part of the experiment. Sharing something unfinished is uncomfortable, especially when you can see every flaw and every shortcut. At the same time, a game sitting on my computer teaches me less than a game that somebody else can play, misunderstand, break, or enjoy.

I do not know how far I will take Unobserved. It may grow for a long time, change completely, or remain as the project that finally made me stop looking at game development from the outside and start experimenting with it myself.

It does not need to become my profession to be worthwhile. Sometimes a side project only needs to make you curious again, force you to learn unfamiliar things, and remind you how much fun it is to build.

For now, that is more than enough.

Thanks for reading, Hack The Planet!