I recently finished my first Unity game — a tiny 1-minute WebGL project called Rocket. It’s simple, built while following a Udemy course, and definitely not a “big” game by any stretch. But it is the first game I actually finished, shared, and received real feedback on. And that alone makes it meaningful.

This post is a short and honest retrospective on that experience.

What Kind of Game Is Rocket?

Rocket is a simple 2.5D mini-game made with 3D assets, focused on balancing thrust and gravity to reach the landing zone.

It’s minimal, a bit clumsy, occasionally frustrating (by design, I guess), and surprisingly fun to watch others attempt. rocket screenshot

Built From a Udemy Course

The entire project comes from the Udemy course: Complete C# Unity 3D Game Development in Unity 6

Following the course gave me a guided way into Unity’s ecosystem:

  • Component-based design
  • Rigidbody and collisions
  • Basic physics interactions
  • Update vs FixedUpdate
  • Debugging through the Inspector

Nothing fancy — but for a beginner, every small concept felt new and occasionally overwhelming.

While it started as simple “follow along,” at some point it shifted into understanding how Unity actually works under the hood.

Challenge #1 — Level Design Is Harder Than It Looks

Designing even a tiny level was way more difficult than I expected.

Moving an obstacle by just 1 meter could make the game either:

  • too easy,
  • impossible, or
  • mildly infuriating (which my mom kindly pointed out).

I realized level design isn’t about placing objects — it’s about shaping the player experience. That was a meaningful lesson tucked inside a tiny project.

Challenge #2 — Getting Comfortable with Unity’s Framework

Unity’s ecosystem was a lot to take in at first:

  • Physics values behaving unexpectedly
  • Components interacting in non-obvious ways
  • Inspector tweaks drastically changing gameplay
  • Confusion between script execution orders

Even for a small game, Unity forces you to think systematically. It was frustrating at times, but also the exact kind of friction that leads to actual learning.

The Best Moment: Sharing It with My Family

The most memorable part of this project wasn’t the development itself — it was sharing the game with my mom and my younger brother.

Their reactions were simple but surprisingly meaningful:

  • “You made this? That’s impressive.”
  • “Why is landing so difficult?”
  • “This game is kind of annoying… but in a fun way.”

It didn’t matter that the game was tiny or built from a course. Watching my own family play something I created — and react to it in real time — made the whole thing feel real.

The game was small. But it was mine, and they played it. That was enough.

What This Small Project Left Me With

Rocket is a tiny game, but it left me with tangible lessons:

  • Finishing something, even a small project, builds confidence
  • Implementation teaches more than theory ever can
  • Sharing your work is part of the creative process
  • Small, repeatable completions accelerate growth much faster than big, unfinished ideas

This project chipped away at the fear of “starting game development.” Next time, I want to build something slightly more original — still small, still simple, but fully mine.

What’s Next

Nothing huge. Just another tiny game — this time with my own design choices and a few more mechanics layered in.

Rocket wasn’t big, but it was a clean first step. And a good first step is all I needed.

Play the Game

If you want to try the tiny project yourself, you can play it here:

🚀 Play Rocket on Unity Play

It’s short, simple, and occasionally frustrating — which is exactly how I intended it.