The Shit Mountain Manifesto

ALTITUDE: ███████░░░ STILL CLIMBING

I built my own game engine. From scratch. In C. It's taken over seven years and it's still not done.

Everyone has an opinion about that.

"Just use Unity." "Godot is free." "Why would you do that to yourself?" "Are you a sicko?" (yes)

Here's why: because it's mine.

Every line of code in my engine is a line I wrote, broke, fixed, broke again, and eventually understood. There's no magic. No black box. No stack overflow answer I copy-pasted and moved on from. When something doesn't work, I know where to look. When I want to do something weird, I can. When I want to build a tool that fits exactly the way my brain works, I build it.

That's Shit Mountain.

Obviously, this isn't a philosophy of perfection. It's about being comfortable sitting in the pile that you made. You made this mess. You understand it. It's only going to get better because you're going to get better, and nobody is going to send you an invoice for that.

The games industry has spent the last two decades selling developers a different story.

The story goes: abstraction is progress. Don't look under the hood. Use the engine. Buy the asset pack. Watch the tutorial. Ship the game. The tools are so good now, you don't need to understand anything. Just assemble.

And developers bought it. Of course they did. It feels easier and it feels faster. There's a YouTube video for every problem.

But something got lost in that deal.

Programmers stopped wanting to understand how things work. They want problems to go away, not understand them. They learned the engine, not the craft. They know how Unity thinks. And that would be fine, a trade-off worth making, if the people selling them the tools weren't also building a trap.

Unity didn't invent the runtime fee out of nowhere. It came from a business model that was always going to end that way. A platform with millions of dependent developers and an obligation to grow revenue forever. The fee was inevitable. Vendor lock-in was the product. The "free" engine was the acquisition strategy.

When it happened, developers were furious. Understandably. They'd built careers on that foundation. Years of work, locked to a platform that just changed the rules.

That's not bad luck. That's what happens when someone else owns your mountain.

Lock-in isn't just the pricing page, though. It's the whole experience. Vendor lock-in is everywhere I look, sold as solutions to made up problems.

Looking up how to make anything in Unity is painful. Every API is different. Every system was built by a different group chasing different goals. Half-baked answers to problems they invented, stacked on top of systems that are already broken. Someone else's opinions about how a tile map should work, buried under someone else's abstraction layer, documented in someone else's way, breakable by someone else's update cycle.

Who wants to sit around and wait for another LTS version with the "fix" promised to "actually work this time"? I've been there. It's terrible. It's annoying. Let me have control and fix the thing. I'm smart and capable.

I'd rather spend that time building something that solves a problem I actually have.

In my engine, I built my tile map in an afternoon. It does exactly what I need. Nothing else. It's probably ugly. I don't care. It works, I understand every pixel of it, and nobody can take it away from me.

Shit Mountain has cost me seven years. Part time, nights and weekends, slow and self-directed. No course. No certification. No right way to do it. Inspired by the Handmade Community, folks making things for themselves, fitting the way their own brains work.

An early engine test window on a dark grey background: the sentence 'The quick brown fox jumps over the lazy dog' rendered in a pixel outline font, a small knight sprite holding a sword and shield, and a teal horizontal bar crossed by a purple vertical bar. — April 2020, the earliest shot I still have. Text rendering, one sprite, two rectangles.

When I first came across that community I thought they were insane. I was five years into the game industry and I thought the way everyone else does. Abstraction is king. Object oriented principles or bust. ECS for performance. Empty words that juniors and beginners get taught and latch onto because it's "how we do things" around here.

This has been the best game dev education of my life.

Not because I'm a masochist (okay, maybe I am). Because self-directed learning compounds. Every system I implement teaches me something that makes the next system easier. My engine understands my games, because my engine was built by the same brain that designs them.

A top-down pixel-art dungeon room with stone brick walls and an orange-brown floor. A character holding a glowing blue sword stands near the middle, a cluster of green slimes gathers around a crate below, and there are dark pits, scattered skulls, and a crosshair cursor. — About a year on. A small playable demo: art, animation, sound effects, music, all of it running on the same handmade pile. Same mountain, taller.

This industry doesn't want you to build your own engine. The big tools want developers dependent. Their business models require it. Acquisition, lock-in, growth. If you can roll your own, you're not a customer. You're a problem.

So be a problem. Be a goblin. Be the weird thing nobody planned for, tinkering away in the dark on something nobody asked for, following a path you cut yourself.

Own your tools. Own your failures. Understand your problems instead of routing around them. Build the thing that fits the way you think, not the way some platform decided you should think.

Your mountain might be ugly. It might be held together with gum and toothpicks and bad variable names and a rendering bug you've been ignoring for eight months.

That's okay.

It's yours.

Climb it.

Wishlist Gobs & Gears and sign up for dispatches from this Goblin.

GOBLINTEK is a one-person game studio. We own our shit.