Building MegaWord: Bringing Wordle to the Sega Mega Drive

Sometimes I wonder if building MegaWord was a childhood dream or a mid-life crisis.

Honestly, both are probably true.

Growing up, I wanted to be a game developer. The console that kicked all of that off for me was the Sega Mega Drive. Like a lot of people my age, that machine felt magical. The music, the pixel art, the challenge of the games, even the boxes and manuals. It all stuck with me.

Fast forward a few decades and I’m now working professionally as a designer, spending my days building digital products, interfaces and experiences. But that desire to make a game for the Mega Drive never really left.

At the same time, I’m also a massive Wordle fan.

So naturally my brain went:

What if I demade Wordle for the console that started it all for me?

That idea eventually became MegaWord.

But what started as a fun experiment quickly turned into a genuine technical challenge involving retro hardware limitations, custom art pipelines, AI-assisted workflows, colour quantisation problems and a huge new respect for the original developers who built games under these restrictions professionally.

Starting With Something Achievable

MegaWord actually wasn’t my first attempt at making a Mega Drive game.

Before this I had started building a platformer using SGDK, the Sega Genesis Development Kit. Like most first game ideas, it was massively ambitious and honestly way beyond my skill level at the time. Eventually I hit a wall and quit.

That failure ended up being incredibly important.

What I learned from that project was to start with something achievable. Don’t try to make Sonic as your first game.

I needed to understand the workflows, tooling, limitations and mindset first. MegaWord became the perfect project for that because the mechanics were simpler but the challenge was still real enough to force me to learn properly.

Ironically, now that I’ve finished MegaWord, I actually feel equipped to go back and tackle the platformer again someday.

Why SGDK?

I chose SGDK because going fully old-school into low-level C development felt honestly quite daunting.

In my day-to-day work I’m used to frameworks, tooling and structured workflows. SGDK gave me a much more approachable entry point into Mega Drive development while still exposing me to the realities of the hardware.

I also spent time reading through the excellent SGDK development book by Zerasul which helped massively when getting started.

That said, there’s still a huge learning curve.

You’re dealing with tile-based rendering, palette limitations, memory constraints, sprite restrictions, ROM size limitations, old audio tooling and hardware quirks. None of it feels modern.

And that’s kind of the point.

Using AI and Codex

One thing people will probably find interesting about MegaWord is that I built it alongside modern AI tooling, particularly Codex and ChatGPT image generation.

But I think there’s a misconception sometimes that AI just magically makes things for you.

That absolutely wasn’t my experience.

Codex helped most with setup, scaffolding and heavy lifting. Getting environments configured, building structures and wiring systems together. It accelerated development massively.

But the mechanics, the design decisions, the direction and the actual feel of the game were heavily directed by me.

AI is incredibly useful but only if you approach it properly.

You still need vision, direction, technical understanding, problem solving, taste and realistic expectations.

My advice to anybody wanting to do something similar would be to treat it like a real project. Don’t just fire prompts at AI and hope for the best. Understanding the technology and its limitations upfront is half the battle.

The Prototype Came Together Fast

One of the most surprising parts of the project was how quickly I got a working prototype running.

Within a relatively short amount of time I had word logic working, controller input, screen layouts, gameplay loops and menus. It became playable fairly quickly.

But then came the real challenge.

Polish.

And honestly, polish consumed far more time than the gameplay itself.

The biggest time sink wasn’t code. It was assets, sprites, logos, sound effects, backgrounds, visual refinement, workflows and presentation. Basically anything that wasn’t generated directly by code.

That was the point where the project really transformed from “working software” into something that actually felt like a Mega Drive game.

Making Wordle Feel Like a Real Mega Drive Game

One thing I realised early was that simply recreating Wordle wasn’t enough.

Wordle is intentionally minimal. You pick it up, do the daily word and come back tomorrow.

That works brilliantly on mobile and web.

But the Mega Drive is a console. I wanted MegaWord to feel like an actual game you’d sit down and play.

So I expanded the concept with timed challenge modes, animations, sound effects, arcade-like pressure, rich pixel-art backgrounds and replayability with over 3000 words.

I wanted it to feel more alive. More game-like. More suited to the era.

The Background Pipeline Nightmare

The biggest technical challenge by far became the backgrounds.

Initially I used ChatGPT image generation to create the artwork. The results were genuinely impressive and gave me a great creative starting point.

But there was a huge problem.

The Mega Drive absolutely hated them.

Modern AI-generated images use enormous colour ranges and subtle gradients. The Mega Drive does not.

The console has severe palette limitations and only allows a tiny number of colours per plane.

The moment I imported my first really nice background image into the engine, it turned to mud.

That single moment probably triggered the biggest technical rabbit hole of the entire project.

I spent a huge amount of time researching colour quantisation, Mega Drive-safe palettes, image conversion workflows, SGDK image handling, palette corruption issues and export pipelines.

My original workflow looked like this:

1. Generate artwork using ChatGPT image generation
2. Resize in Photoshop
3. Convert to indexed colour
4. Reduce to 16 colours

But even after all of that, SGDK would still quantise the colours again and completely destroy the image quality.

So I ended up building my own custom colour swapper tool.

The tool allowed me to automatically convert Photoshop colours into Mega Drive-safe colours, preserve visual consistency, manually repair blemishes with a pencil tool and bypass parts of the default SGDK image workflow entirely.

Eventually I created a custom pipeline that allowed the images to appear 1:1 exactly how I intended them to look.

That entire process probably taught me more about retro hardware than any other part of the project.

Bringing Modern UX Into Retro Hardware

Another interesting part of the process was using Figma heavily during development.

A lot of people associate retro game development with specialised pixel art software but honestly, Figma just made sense to me because I use it every single day professionally.

I found myself composing game scenes the same way I’d compose a website, product UI or presentation.

The skills transferred surprisingly naturally.

In many ways MegaWord became an experiment in bringing modern UX thinking into retro hardware.

How do you make something readable? How do you guide the player? How do you make menus intuitive? How do you communicate information clearly within strict visual limitations?

Those are UX problems.

The medium was just different.

The Strange Beauty of Limitations

Modern game development can feel almost unlimited. You have full motion video, high-resolution graphics, endless colours, huge storage, high fidelity audio and gigantic asset libraries.

On the Mega Drive you’re suddenly thinking about fitting everything into 2MB to 4MB, palette restrictions, compression, tile memory, limited sound channels, file size management and sprite budgets.

It feels restrictive.

But weirdly, it also feels liberating.

Because limitations force decisions.

You stop endlessly adding things and start asking:

“What actually matters to the experience?”

That mindset was one of the most rewarding parts of the entire project.

Testing on Real Hardware

Most development happened using RetroArch and BlastEm on my Mac.

But every time I hit a meaningful milestone, I’d copy the ROM onto an SD card and test it on original hardware using an EverDrive cartridge connected to my Mega Drive 2 and CRT television.

The first time I saw something I created running on original hardware was honestly an amazing feeling.

There’s something surreal about it.

You grow up playing these systems as a kid and suddenly your own work is appearing on that same screen.

That moment made the entire project feel real.

More Than Just The ROM

One thing I’m excited about after release is that MegaWord extends beyond the software itself.

I’ve already bought blank cartridges and a flash kit to produce a limited physical run of the game. As a designer, I’m genuinely looking forward to the surrounding design work too: the box art, cartridge labels, website and hopefully even a physical manual.

I also plan to release the ROM online through the game website and itch.io alongside future updates, new modes and expanded word lists.

A Huge Respect For Original Developers

One thing this project gave me above all else was perspective.

An enormous amount of perspective.

Retro development is hard.

Really hard.

And I say that as somebody who had access to modern frameworks, modern computers, modern research, modern communities, AI-assisted tooling and modern art workflows.

Even with all of that, this project was still a challenge.

So I now have absolute respect for the original developers who built games commercially under these limitations every single day and equally for the modern homebrew community who continue doing it now.

MegaWord would not have happened without modern tools and AI helping accelerate parts of the process.

But those tools don’t remove the challenge. They just make the mountain climbable.

In the end, MegaWord became more than a Wordle-inspired game running on a Mega Drive.

It became a gift from middle-aged me to 12-year-old me.