Aranok Engine

Aranok Engine

Hey all — After careful consideration, I'm releasing the source code to Aranok Engine, a client/server MMO engine I've been building from scratch in C#. If you've ever wanted to run your own persistent online RPG — think old-school RuneScape/Tibia-style multiplayer, but built on a modern .NET stack instead of Java applets — this is the foundation.

Price: $20 USD, one-time. Get the full source. It's yours — completely.

What this actually is:

This is not a single-player RPG Maker–style toolkit. It's a real client/server architecture — a persistent world that a dedicated server authoritatively runs, with any number of clients connecting to it over the network. If you want a game where players log into the same world, see each other, fight the same monsters, and trade with each other in real time, this is built for that from the ground up. All-in-one project solution, clean and simple!

The Specs (I'm not going to oversell this — here's what's actually in the box)

• C# 12 / .NET 10

• Client: MonoGame (DesktopGL/OpenGL) — this is a real 2D game client, not a mockup

• Editor: Avalonia (cross-platform desktop UI)

• Audio via NVorbis, fonts via FontStashSharp, small/clean dependency footprint — no bloated third-party middleware you have to license separately

Architecture — 4 clean projects, ~46,000 lines of code, one solution!

• Aranok.Engine — shared library: networking protocol, data models, content pipeline, render helpers

• Aranok.Server — the authoritative game server (TCP + TLS, plus an HTTP content server for asset delivery, so people can't modify assets)

• Aranok.Client — the MonoGame player client

• Aranok.Editor — a full Avalonia-based content/map editor

Runs anywhere, right out of the box. Because it's built entirely on .NET 10 with MonoGame's DesktopGL backend and Avalonia for the editor — both cross-platform by design — this isn't a Windows-only engine that happens to compile elsewhere. It's a standard .NET solution: open it in Visual Studio, JetBrains Rider, VS Code, or literally any editor/IDE that can drive the dotnet CLI, and build. No proprietary toolchain, no vendor lock-in to one editor.

• Windows — works out of the box

• Linux — works out of the box (DesktopGL + Avalonia are native there)

• macOS — works out of the box

Run the server on a Linux box in a data center, develop the client on your Windows or Mac laptop, edit content in the Avalonia editor on whatever you're sitting at — it's all the same codebase, no platform-specific forks to maintain.

Networking

• TLS-encrypted TCP connection, length-prefixed message framing

• Server is fully authoritative — HP, damage, loot, and combat outcomes are all decided server-side, not trusted from the client. This matters if you care about not getting your economy destroyed by a memory editor on day one.  

• Current payload format is JSON over the wire (readable, easy to debug/extend) — the framing is already built to drop in packed binary later if you want to squeeze bandwidth, but out of the box it's JSON so you can actually read your own network traffic while building. 

 

Game systems that are actually implemented and working, not stubbed:

• Melee & ranged combat, NPC AI (aggro, retaliation, leashing, wandering, respawns)

• Boss encounters with HP-threshold telegraphed abilities

• Threat-based target switching

• PvP (map-flaggable)

• Inventory, equipment, banking

• Resource gathering gated by skill level

• Timed crafting stations

• Shops

• Player trading (escrowed, two-party — no scam trades)

• Parties with leader/invite system  

•Quests with staged objectives (kill/collect/use/equip) and rewards  

• A full skill/XP system with its own curve

• A* pathfinding with diagonal movement  

• Chat system  

• Combat logout grace periods (no logging out to dodge a fight)

• Lighting AND Particle system

• Ability to separate free players or paid subscriptions within the Editor

The Editor — this is a real tool, not an afterthought:

  • Live map editor with ground/mask/fringe layers, with live reload to connected players while you edit

  • Full autotile support (Normal, Fake, Animated, Waterfall, Cliff blob autotiling)

  • Tileset and sprite importer

  • Item, spell, NPC, quest, shop, crafting, and class editors

  • Character customization editors (hair, paperdoll layers)

  • Admin authentication over the same secure connection as regular play

Scripting / Events

  • A custom event-command interpreter, RPG Maker–style, built from scratch (not Lua — a purpose-built flat-command DSL): switches, self-switches, variables, conditional branches, player choices, warps, item/spell rewards, shop/bank/crafting triggers, camera and screen effects. If you've ever built an RPG Maker event chain, this will feel immediately familiar — except it fires server-side, for every player, live.

• Administrative account editor for Admins/Developers.

• Player Moderator roles

Persistence:

• JSON-based save system right now: per-account files with PBKDF2-SHA256 password hashing, plus a game-content database abstraction with a master/published-content split. There's no heavyweight SQL server dependency to stand up — but the interface is written so you can swap in a real database later if you outgrow flat files.

 

Graphics — NOT included:

No art assets ship with this engine. The tile and sprite pipeline is built to be compatible with the RPG Maker VX Ace / MV tileset and autotile conventions (32×32 tiles, A1–A4 sheet layout), because that's a well-understood, well-documented format with a huge amount of existing content around it. That means:

• If you own RPG Maker and its RTP, or you've purchased tilesets/sprites made for RPG Maker, they will drop right in.  

• If you don't own a license for those assets, you need to source your own graphics — there are tons of commercial and free tileset packs built for this exact format, or you can draw your own. This engine gives you the game, not the art.

It is genuinely yours — no strings, period

You buy it once, for $20. That's the entire transaction. After that:

 

• You own it, full stop. No royalties. No revenue share. No "you owe us if you make money." No license agreement dictating what you're allowed to build.  

• Do absolutely whatever you want with it. Build a commercial game and sell it. Run a private server for you and your friends. Use it as a learning project. Rebrand it and resell or redistribute it as your own if that's what you want to do. It's your codebase — I'm not retaining any claim over what you do with it after purchase.  

• Full source, no obfuscation. Read it, rip it apart, rewrite the combat system, throw out the networking layer, keep only the editor.  

• Free updates for as long as you own it. Anyone who buys gets every future update I push to the engine, forever, at no extra cost. No subscription, no "buy the DLC to unlock the update."  

• The only stipulation: no refunds. Once you've bought it and have the source in hand, that's final — same as buying any other piece of source code or software on here. Everything else is unrestricted. 

 

Being straight with you about where it's a:

I'd rather tell you now than have you find out after buying:

• Movement is currently client-reported and polled rather than full client-side prediction/reconciliation — fine for a game like this, but don't expect Counter-Strike–tier netcode.

• Persistence is flat JSON files, not a proper database — great for getting started and for small-to-mid player counts, something you'd want to revisit at real scale.  

None of these are dealbreakers — they're exactly the kind of thing a $20 engine leaves for you to shape to your own project instead of dictating for you.

Who this is for:

• Beginners: if you've used RPG Maker and always wondered "what would it take to make this multiplayer," this is that answer, already built, with an editor that will feel familiar on day one.

• Serious developers: if you want a real authoritative-server MMO foundation in modern C#/.NET instead of writing your own netcode and combat/inventory/quest systems from a blank file, this saves you months. Combat system alone is ~3,000 lines of working server logic you don't have to write yourself.

$20. One time. Full source, fully yours — sell it, redistribute it, build on it, whatever you want. No refunds, no other strings. Free updates for life. Runs on Windows, Linux, and Mac out of the box, in whatever IDE you already use. Bring your own art.

Setup:
Simply load up your IDE, such as Visual Studio, create a multi-run debug consisting of the client, server, and editor, launch the client first, and make your account. Then, in the server, use the /help commands, make yourself an admin, and log in to the editor with your admin account to import your tilesets, sprites ect, etc. Then log in to the game client to watch your world come alive.

Official Discord for support: https://discord.gg/DB57DFVRtN

Screenshots: