Why am I telling you this when I'm supposed to be talking about the story for our dark fantasy top-down MMORPG?

Because there's a feeling that comes as you go through grief and start to forget someone, and it's complex. In a way it's a relief, because you're not living so directly with the pain anymore. But it's also frightening, because you're forgetting.

Dad died under pretty mysterious circumstances and we never really got a definitive answer for how, or what happened that night. We're all at peace with that mystery now. But the best advice I ever got was to face the grief head on and never shy away from it. And I did. We both did. (Al had his first kid due in a month, so that was a blessing we all needed.)

When we started writing Mortumus’s quest line and lore, it got us thinking about the opposite. What happens when you don't face it? Where would we be now if we hadn't?

That question is what inspired the first story within Mortumus. It's a journey to forget. To escape something too painful to remember. But if you follow the quest line, you'll be forced to remember anyway, and confront the thing you've been running from. Along the way you might help the world, or you might just decide to leave it the way it is.

Because this "forgetting," we'll call it, isn't only the character's journey. It's the world's. Mortumus is a world that has forgotten itself.

And I mean that literally. The whole world is written in a language no one alive can read. It's carved into everything, the walls, the ruins, the gravestones, the bedrock under your feet. It's been there for hundreds of years and the people living in the world walk straight past it, like it's just weathering on old stone. They've forgotten it was ever language at all.

But it is a real language. We built the whole thing, real rules and all, and you can actually learn to read it. And nobody does it alone. This is an MMO, one shared world with thousands of people in it, and across the whole server players piece the language back together fragment by fragment. As they do, the world starts giving up what it used to be. Directions. Names. History. What this place was before it forgot itself. The world only remembers because everyone is remembering it together.

It's a hard world, too. One place, everyone in it, real consequences when you die. But the thing we kept coming back to while we wrote it is that a whole world full of strangers is quietly, stubbornly helping a forgotten place remember what it was, and most of them don't even know that's what they're doing.

You don't need to have lost a dad on a yacht to feel any of this. Everybody is carrying something they've quietly decided not to look at. The game just turns that into a place you can walk through.

We didn't set out to make a game about grief. We set out to make the game two brothers always wanted to make, on nights and weekends, with nobody's permission. But the story we kept writing turned out to be the one we were already living. A world that forgot itself, and thousands of people slowly remembering it back, together. That's Mortumus. And building it is how we faced ours.

While Fin is buried in the server mines wrestling with databases, subscriptions, and all the scary distributed-systems wizardry that keeps the world alive, I'm the one on the other end making sure every sword swing, footstep, torch flicker, and piece of armour actually looks and feels right on your screen.

Building a dark fantasy MMO isn't the kind of thing you can drag-and-drop together from an asset store. The gritty, old-school feeling we're chasing — the weight of the combat, the creak of your armour, the dread of seeing another player on the horizon — only comes out when the tools underneath are built specifically for it. So today I'm pulling back the curtain on a few of the custom Unity systems we've been cobbling together on the client side: the ones nobody will ever see, but that everyone will feel.

Let's get into it.

Visuals, Loot, and PvP Privacy

If there's one truth about MMO players, it's this: we love gear. And in a full-loot PvP game like Mortumus, gear isn't just a dopamine drip — it's information. What someone's wearing tells you what they can do to you.

Keep It Secret, Keep It Safe — Equipment Visualizer

Early on we realized we had a problem that a lot of MMOs quietly ignore: if the client knows the exact item ID of every piece of gear on every player in view, a determined cheater can scrape that out of memory and know your exact stats before they decide to gank you.

So, our Equipment Visualizer does something slightly paranoid. For your own character, it reads from the full equipment service — you see everything about your gear. But for every other player, it only reads a stripped-down "visuals" blob the server publishes. You see the sword, not the stat sheet. Strangers' item IDs simply never leave Fin's server.

It's a small thing. It also makes memory-scraping cheats a lot less useful. Good trade.

The Animation Stack

Skill-based combat lives or dies on animation. If the windup isn't readable, you can't react. If the hit doesn't land, the fight feels weightless. If death looks like the model just… turning off, you lose half the mood.

Player Animation Coordinator

We started out the way most people do: one gigantic animation controller class trying to manage everything. Movement, spells, death, hits, idles — all in the same file. Within about two weeks it was a mess.

So, we broke it apart. Now the Player Animation Coordinator is a tiny entry point that spins up a stack of small, specialized modules: movement, rotation, attack, spell, hit reactions, death, idles. Each one owns one job. Each one is readable on its own. Bugs take minutes instead of hours to track down.

Cleaner code for me. Tighter combat for you.

Combat Responsiveness — Attack Animator & Spell Animator

Here's the classic MMO problem: server-authoritative combat is the only way to stop cheating, but waiting for the server to confirm every cast feels like molasses.

Our Spell Animator cheats a little — but honestly. When you hit your spell key, the cast animation plays immediately — locally predicted, so it feels instant. Then Fin's server validates whether the cast was actually legal (off cooldown, enough mana, target valid, etc.). If it confirms, nothing changes. If it rejects, we cleanly snap out of it.

Attack Animator does the same dance for melee, and it even scales the swing speed to match whatever cadence the server says your weapon attacks at. Your eyes see responsive combat. The server sees a world that can't be lied to.

That sweet spot between "feels good" and "plays fair" is where this whole game lives.

The Sounds of the Realm

Audio is 50% of mood and people always underrate how much work it takes.

Setting the Atmosphere — the Audio Manager & Music Region System

Traditional games tend to change music by hard-cutting when you cross an invisible line. It's jarring. We do it with 3D polygon zones. The Music Region System lets us paint arbitrary-shaped areas in the world — a haunted grove, a cursed chapel, the approach to a boss — and as you walk in and out, the Audio Manager crossfades the soundtrack smoothly. No cuts. No restarts on the same track if you toe over the boundary.

And because all of this runs through pooled audio sources with mixer-group routing, it costs basically nothing in frame budget.

The Character Audio Manager

Every footstep in Mortumus is wired to your character's animation and the surface underneath you — stone sounds like stone, mud sounds like mud. Spell sounds are tied to the ability, weapon swings to the weapon. The Character Audio Manager sits between the animation events and the Audio Manager so we can swap in new SFX packs per race/class without touching any gameplay code.

Little things. Lots of them. They add up.

The Water's Edge

Every dark fantasy world has water in it. Swamps, rivers, flooded ruins, the sea at the edge of a cursed cape. And water is one of those things that looks fake really easily — especially where it meets land. That ugly polygonal waterline where the mesh intersects the terrain is the hallmark of a cheap-looking game.

Our Water Base

We didn't build our water from scratch. Unity actually ships a fantastic demo project called Boat Attack that includes one of the best URP water systems out there; real reflections, refractions, buoyancy, the works. So, we started with Boat Attack's water as our foundation, because reinventing that wheel would have cost us months for no real gain.

But Boat Attack was built for, well… boats. Nice clean ocean shorelines. The shoreline behaviour that looks great on a sandy beach looks terrible around the muddy, reedy, irregular waterways we actually want in Mortumus. So, we had to get surgical.

The Custom Shader — Water Shoreline

Instead of editing the Unity package directly (which would have broken every time we updated it), we wrote a thin custom shader "WaterShoreline" that swaps out just the piece of the pipeline responsible for the shore. Everything else — reflections, flow maps, caustics — comes straight from Boat Attack. We only override what we need.

The big two changes:

The hard 2-meter foam cutoff is gone. Boat Attack's default foam band has a fixed depth cutoff, which gives you that uniform "ring of white" around every shore. We replaced it with a softer falloff plus a scrolling noise field, so the foam now fades gradually and breaks into organic tongues and fingers instead of a perfect ribbon.

Soft shoreline alpha. That polygonal waterline-against-terrain problem? We fade the water itself to transparent over the last half meter of depth. The waterline disappears entirely. The terrain just gets darker as it goes underwater, the way a real wet shoreline does.

Our River System

Here's the thing about Boat Attack's water: out of the box it handles oceans beautifully, but it doesn't really know what a river is. Water can ripple in place, but it can't flow downstream and around a bend the way a real river does. That's a problem when half of your dark fantasy world is supposed to be swampy, riverine, and soaked.

So, we built a river system on top of it.

A river in Mortumus is authored as a flow path — a simple polyline of points that traces the spine of the river from source to mouth. Designers drop the points where they want water to flow, and the shader does the rest: for every pixel of water surface, it figures out which segment of the flow path is closest and uses that segment's direction as the local current. Result: water near a straight section flows straight, water on the inside of a bend curves with the bend, and everything transitions smoothly in between.

The textures, normals, and foam all scroll along that flow direction instead of drifting aimlessly. You can actually see which way the river is going.

All of it is tunable live from ShoreFoamTuner, a tiny inspector component we drop on any scene with water. Sliders for foam softness, noise scale, noise strength, drift speed, alpha falloff. Change the mood of an entire lake without touching a material.

Community and Trash Talk: Chat & Social

An oldschool MMO is as much about the people as the game. If the social tools feel bad, the world feels empty.

Overhead Chat System

Text anchored right above a character's head, following them as they move, fading at distance — it's an absolute staple of the genre, and something we will die on a hill defending.

It turns parties into actual conversations. It lets you trash-talk someone mid-fight. It lets the last words of a dying player be something dumb and funny instead of a system log line. The Overhead Chat System handles pooling, distance culling, and anchor tracking so it scales even when twenty people are all yelling at each other in a cramped dungeon.

Looking the Part

Be honest — you're going to spend an embarrassing amount of time in the character screen. We all do. It's the nicest mirror in the game.

The Character Preview System

Our paper doll isn't a baked 2D render — it's a live 3D scene rendered into a UI render texture. Full lighting, real geometry, every piece of gear on you in real time. Rotate it, zoom it, stare at it. It's the kind of feature that doesn't change gameplay at all, and absolutely changes how the game feels to own.

Filling the Bags: Icon Studio

Here's a dirty little secret of MMO development: icons. You need hundreds of them. Every sword, every potion, every piece of trash loot you find in a chest needs its own little 64x64 square that reads cleanly in a cluttered inventory. And they all need to look like they belong to the same game.

You can't just screenshot a 3D model and call it a day. The lighting needs to be consistent. The camera angle needs to be consistent. And — this is the bit everyone underestimates — the framing needs to match the grid size the item will occupy in the inventory. A 1x1 dagger and a 2x3 great sword need wildly different compositions or they both look wrong.

Our Solution: Icon Studio

Icon Studio is a custom Unity editor window we built so one person (usually me, muttering) can churn out a hundred consistent icons without losing their mind.

The workflow: drop in a list of item prefabs. Tell the tool what grid size each one occupies in the inventory — 1x1, 2x2, 2x3, 1x4, whatever. Frame the camera once. Save the framing as a preset. Hit Generate.

The magic is that the grid size isn't cosmetic — it drives the actual render. A 2x3 item gets rendered at 2x width and 3x height (of a 512px base), so when it sits in your inventory the proportions are correct, not stretched. A longsword genuinely fills a 1x4 slot diagonally. A potion bottle genuinely fits in a 1x1. The inventory feels like you're organising real objects.

On top of that, the tool handles: transparent or custom backgrounds per item, bone pose capture so skeleton-based items can snapshot their display pose without disturbing the gameplay rig, and presets for entire item categories — all axes render with the same camera, all potions with a different one. Consistency for free.

The end result is that every icon in the game — the ones that read well at 32 pixels in a dense inventory grid — was rendered from the actual in-game model, at the actual shape that item takes up in your bag. No outsourced 2D art. No mismatched lighting. No dagger that somehow looks bigger than a great sword in the UI.

It's the kind of tool nobody sees. It's also the reason the inventory doesn't look like a bag of mismatched stock art.

Until Next Time

None of these systems are the headline features of Mortumus. Nobody's going to buy the game because the footsteps sound nice or because skeletons explode into physics chunks. But these are the bones underneath everything — the invisible work that makes the big stuff feel right when it lands on top of them.

With this foundation in place, Fin and I can build the actual grim, brutal, full-loot world we've been sketching in notebooks for two years — at a pace that doesn't make us want to throw our computers into a river.

— AL

That's not what we're building. MORTUMUS is built to fix this.

The Problem With PVP Zones

Most MMOs solve PVP by putting it in a box. There's a "PVP zone," a designated area where players can fight. Sounds fair. But here's what actually happens: the strongest players camp those zones. They know that's where the fights are, so that's where they go. For everyone else, the PVP zone becomes a place you avoid. The feature that's supposed to be exciting becomes a corner of the map most players never visit.

Zoned PVP doesn't spread danger. It concentrates it. And concentrated danger isn't exciting. It's a death sentence for anyone who isn't already at the top.

Why Open World Changes Everything

In MORTUMUS, PVP isn't in a zone. It's the world. Danger is everywhere, but because it's everywhere, it's not concentrated. You might run into trouble on a forest path, or at a mining node, or crossing a bridge. Or you might not. That uncertainty is what makes every journey feel alive.

Every player you see is a question. Are they friendly? Are they armed? Do they need something you have? Open-world PVP turns every encounter into a decision. Fight, flee, trade, or trust.

The Stranger Problem

There's a moment that most MMOs have designed away completely. You're walking through the wilderness. You see another player in the distance. You don't know their level. You don't know their intention. Do you approach? Do you hide? Do you wave and hope they wave back?

That tension, the not knowing, is the most human moment in gaming. Most developers remove it. Faction tags tell you who's an enemy. Nameplates show you their level. PVE servers remove the threat entirely. All of that kills the moment.

We want to keep that moment alive. Because the stories players remember aren't scripted quests. They're the time a stranger helped them fight off a monster and then disappeared. Or the time they trusted someone and got betrayed. Those moments only exist when the danger is real.

The Games That Got It Right

We're not building this in a vacuum. The games that shaped how we think about this are the ones that understood danger makes everything else matter.

In the early 2000s, there was a game most people have never heard of called Xenimus. For a brief window, it had this exact feeling. Open world, real danger, every player encounter charged with uncertainty. But power creep set in, high-level players made life miserable for everyone else, and the developer never found a solution. The feeling died. We never forgot it.

Diablo II nailed the combat feel. Dark, fast, visceral. Your build and your decisions defined you. RuneScape proved that a persistent world with sideways progression could keep players invested for years. World of Warcraft showed that real players in a shared world create stories no developer could script. And ARC Raiders captures something we care about deeply. That feeling where every other player is a question mark. Friend or threat. Help or danger. Trust as a decision you make in real time, with real consequences.

If you're an MMO player, the first comparison you'll probably reach for is Albion Online. Open world, full loot, player-driven. On paper it sounds similar. But Albion still gates its PVP behind colour-coded zones. Safe zones offer weak rewards. Dangerous zones are dominated by geared players who stat-check you before the fight even starts. That's still concentrated danger with extra steps. And its combat, isometric, cooldown-based, designed around clarity over feel, is a different philosophy entirely. We respect what Albion has built, especially its player economy. But the moment-to-moment experience we're chasing is something else.

MORTUMUS lives at the intersection of what all of these games got right, and the lessons from what they got wrong. The combat feel of an action RPG. A persistent world that doesn't reset. Sideways progression that respects your time. And the tension of knowing that every player you meet is making the same choice you are: whether to trust you.

Small Safe Zones, Big Consequences

We do have safe zones. Small ones. Squares within towns. Protection tiles where no one can hurt you. But they're small on purpose.

When the safe space is small, players stand close together. You see the same faces. You overhear conversations. Someone offers to trade. Someone warns you about a group of players hunting near the south gate. Alliances start here. Rivalries too.

Small safe zones don't just protect players. They bring them together. And in a game where trust matters, the places where people gather are where the real game begins.

What Happens When You Die

Let's talk about the elephant in the room. Full loot. When you die, you can lose your equipment and experience. That sounds brutal, because it is. It has to be. Without real stakes, none of the rest matters. The stranger on the road isn't scary if dying is just a minor inconvenience.

But we're not interested in punishing players for the sake of it.

There are items in the game that can protect your experience and equipment when you die. How you get them, how you use them, and the choices around when to carry them. That's part of the gameplay. Preparation matters as much as skill.

And then there's the Ghost Revenge system. We're not ready to reveal how it works yet. But here's the design principle behind it: death should create gameplay, not end it. Getting killed, even by someone far more powerful than you, isn't the end of your story. It might be the beginning of theirs.

Killing someone in MORTUMUS might be the worst mistake you ever make.

Why We're Building This

We're two brothers from Australia, and we've been dreaming about this game for 15 years. Talking about it over beers. Arguing about mechanics. We tried building it a few times, kept hitting walls, and eventually found the right tools to actually get it moving.

AL runs manufacturing systems for the family business. Fin directs and produces science documentaries for the national broadcaster. MORTUMUS gets built in the hours between.

This is a passion project. No kickstarter. No investors. No pay-to-win. Just two dumbasses from Australia making the game they've always wanted to play. We don't mind taking cash out of our paychecks because this is fun. Building it together is the point, and that's what we want the game to be too. Not just something you play, but somewhere that brings people together.

We've been the low-level player getting ganked with no recourse. We've watched PVP zones turn into arenas for the top 1%. We've played MMOs where the world felt alive for the first month and then turned into a lobby for endgame dungeons. A smaller arena PVP game would be easier to ship, but it wouldn't scratch the itch. The persistent world is the point. A world that keeps going when you log off, where you run into the same faces and build rivalries and alliances that mean something.

We believe there are other players out there who want what we want. A world that stays dangerous, stays social, hides secrets worth finding, and treats every achievement like it was earned. A game where the best moments aren't designed by developers. They're created by players, in a world that gives them the freedom to surprise each other.

Maybe we're naive. But we've been thinking about this game for so long.

That's MORTUMUS.

— FIN