Murder is a pixel art ECS game engine built on top of FNA, written in C# and licensed under MIT, intended for developers who want to build 2D games around worlds, entities and components while keeping full control of their own project.

What it is

Murder is an in-development game engine for pixel art games, written in C# and built on top of FNA. Its architecture is centred on ECS — worlds, entities and components — which the engine gets from Bang, the framework Murder uses for its entity-component-system implementation. A game made with Murder follows a defined layout: a root containing resources and src, a game folder holding bin (the final game), packed and resources, and a separate game.editor folder with its own bin and resources. The engine is distributed as source rather than as a package, and the README points to a Hello World project and a game jam project as the fastest way to see how the architecture works.

The specific thing Murder replaces is the external editor executable. As the README puts it, there is no external editor.exe — only your own project — so editor code never touches the game code, and the developer can do whatever they want on the editor side. That is a deliberate contrast with the usual experience of developing a MonoGame or FNA project, where tooling and game code sit together, and with editor-centric engines that take ownership of the project layout. Keeping the editor as its own project means the game code stays as efficient and as controlled as the developer wants it to be.

Key capabilities

• An ECS architecture of worlds, entities and components, provided through the Bang framework.
• Built on FNA and aimed at pixel art games.
• No external editor.exe: the editor is its own project (game.editor) with its own bin and resources, kept separate from the game project.
• A defined project structure of root, resources and src, with the game under src/game and its build output in bin, alongside packed and resources folders.
• Development supported on Linux, macOS, Windows and Steam Deck, with the .NET 8 SDK as the only stated requirement.
• Games can target Linux (including Steam Deck), macOS and Windows.
• Referenced as a git submodule in the project's .csproj, since no NuGet package exists yet.

Who uses it and how

• Developers learning the engine through the Hello World project (hellomurder), which shows how to create a world, entities and components.
• Game jam participants and small teams, who can study the neocityexpress game jam project to see what the Murder architecture looks like in practice.
• Developers working across Linux, macOS, Windows or Steam Deck, who need only the .NET 8 SDK to run the editor.
• Teams that want to write custom editor tooling without that code living in the same project as the game.
• Projects targeting desktop platforms, since console support is still in progress.

Getting started

There is no NuGet package for Murder yet, so the recommended route is to keep the engine as a git submodule and reference it from your .csproj, following the Hello World example. All that is needed to run the editor is the .NET 8 SDK.

How it compares

The README places Murder alongside MonoGame and FNA, describing the development experience as very similar to building a project with either of those. The difference is that Murder layers an ECS architecture and a separate editor project on top of an FNA foundation, rather than leaving the developer to assemble those pieces themselves.

When to use it — and when not to

Murder is explicitly an in-development engine, and the README warns that it will change quite a lot, that release branches are the stable option, and that breaking changes should be expected — so it suits developers who can absorb churn and are willing to track the source through a git submodule. Console support is still in progress and there are no plans to support web or mobile, which rules it out for teams shipping to iOS, Android or browsers. Contributions containing LLM or other generative AI code are not accepted, and the README is thin on step-by-step documentation, pointing readers at example projects and the Bang documentation instead.

└── root 
    └── resources
    └── src
        ├── game
        │   ├── bin (final game)
        │   ├── packed
        │   └── resources
        └── game.editor
            ├── bin (game editor)
            └── resources