This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
I built NovaDash, a retro-inspired terminal arcade dungeon crawler written in Go using the Charm ecosystem.
Originally, NovaDash wasn’t supposed to become a full game at all. I originally created the project as a way to learn Go while exploring the terminal UI ecosystem from Charm.
I was fascinated by how modern terminal applications could feel animated, interactive, and visually polished instead of looking like traditional command-line tools.
The project started as an excuse to experiment with several parts of the Charm ecosystem, including:
- Bubble Tea for the core application architecture and game loop
- Lip Gloss for styling and retro terminal visuals
- Bubbles for reusable TUI components
- Harmonica for smooth animations and motion
- Charm Log for structured logging and debugging
At the time, I just wanted to see how far I could push a terminal application aesthetically and mechanically. So I built a tiny retro-style prototype to experiment with movement, rendering, and gameplay ideas inside the terminal.
Then I abandoned it.
For a long time, it sat untouched in my computer archives as a half-finished experiment that never really became a “real” game.
When the Finish-Up-A-Thon challenge appeared, I decided to revisit the project and see how far I could push the idea.
That abandoned prototype eventually evolved into a full arcade experience featuring:
- 50 handcrafted levels
- Animated ASCII visuals
- Multiple enemy types
- Power-ups and inventory systems
- Time manipulation mechanics
- Save/resume support
- Scoring and leaderboard systems
- Embedded retro soundtrack/audio
- AI autopilot
- Automated testing
- Cross-platform builds for Linux, macOS, and Windows
The entire game runs directly inside the terminal.
One of my favorite parts of the project was pushing the terminal beyond what people normally expect from it. I wanted NovaDash to feel fast, chaotic, colorful, and arcade-like instead of feeling like a traditional CLI application.
Demo
GitHub Repository
Check out the repo to download the game, no development required:
Before — The Original Prototype
This was the original version before the challenge:
You can also see how small the original project was by looking at the very first commit:
At the time, it was mostly just movement, simple enemies, and rendering experiments.
Final Result — NovaDash Today
By the end of the challenge, the project had transformed into a full retro arcade-style dungeon crawler running entirely inside the terminal.
The Comeback Story
The biggest change wasn’t just adding features — it was turning the project from a prototype into something that actually felt complete.
At first, NovaDash was only a small experiment to learn:
- Go
- terminal rendering
- The Elm Architecture (TEA)
- and the Charm ecosystem
I was especially interested in how Bubble Tea structures applications into:
- Model → state
- Update → logic
- View → rendering
That architecture ended up making the game surprisingly scalable as more mechanics were added.
The original version was extremely simple. It had:
- basic movement,
- primitive enemies,
- and minimal gameplay.
Coming back to the project for the challenge, I wanted to push the idea much further.
Over time I added:
- handcrafted level progression,
- more advanced enemy behavior,
- inventory systems,
- tactical power-ups,
- time-based mechanics,
- save/resume functionality,
- audio,
- visual polish,
- and gameplay balancing.
Some of the new mechanics included:
- Space Bombs
- Speed Boosts
- Time Rush
- Time Slow
- Invincibility
One feature that became unexpectedly useful was the AI autopilot system.
Originally it started as a fun experiment, but it quickly became an important debugging and balancing tool because it could automatically play levels and help verify that every stage was actually beatable.
I also wanted the project to feel like a real downloadable game rather than just a source repository.
To make that happen, I added:
- automated tests,
- GitHub Actions CI pipelines,
-
and cross-platform builds that generate native executables for:
- Linux
- macOS
- Windows
That way players can simply download the game and run it directly without needing to build from source themselves.
The soundtrack and audio (generated with Suno) were also embedded directly into the binary, helping reinforce the retro synthwave arcade atmosphere.
My Experience with GitHub Copilot
GitHub Copilot became a huge part of the development process for NovaDash.
I used several models throughout development depending on what I was working on:
- GPT-5.4
- GPT-5-mini
- gemma4:31b-cloud through Ollama
What surprised me most was how iterative and collaborative the workflow became.
I didn’t design the entire game upfront.
Instead, the project evolved feature by feature.
Often I would finish implementing one mechanic, and Copilot would help suggest the next logical improvement or expansion idea.
For example:
- after adding bombs, new tactical gameplay ideas appeared,
- after implementing progression, level balancing evolved,
- after improving enemies, the autopilot system emerged,
- and after polishing gameplay, more quality-of-life systems followed.
That iterative loop is honestly how the game became much larger and more polished than I originally expected.
I also experimented with:
- custom Copilot skills,
-
AGENTS.md, - structured prompting workflows,
- and architecture guidance systems.
Some resources that helped:
- https://github.com/github/awesome-copilot
- https://github.com/obra/superpowers
- https://github.com/multica-ai/andrej-karpathy-skills
One thing I really liked about the process was that Copilot didn’t just help speed up coding — it helped sustain momentum. Reviving an abandoned project can be difficult, but having an AI workflow that constantly helped iterate on ideas made it much easier to keep improving the game piece by piece.
Finishing NovaDash ended up becoming one of the most satisfying projects I’ve worked on, especially because it started as something I thought I would probably never touch again.