# Murder: a C# pixel art ECS engine where the editor lives inside your game

> An entity component system built on top of FNA, shipped as source rather than a NuGet package, with a deliberate architecture choice that has no separate editor executable.

**isadorasophia/murder** — Murder is a pixel art ECS game engine.

- Repository: https://github.com/isadorasophia/murder
- Website: https://isadorasophia.com/murder/
- Stars: 3,327 · Forks: 97
- Language: C#
- License: MIT
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/isadorasophia-murder

## An engine distributed as source, not a package

The first thing to understand about Murder is that you do not install it. There is no NuGet package, and the documented approach is to keep a git submodule and reference it from your `.csproj`. The README links to the Hello World project's project file as the working example of that wiring.

That is an unusual distribution model for a game engine, and it follows from the project's stage. The README opens with a warning block, complete with construction emoji, telling you to proceed at your own risk and describing it as an in-development engine that will change quite a lot. It does make one commitment: release branches are kept stable, while breaking changes are expected in quantity. So the version you pin is the version that moves, which is exactly what a submodule gives you and what a package with a semver policy would not.

The repository is a Visual Studio solution, `Murder.sln`, with a shared `Directory.Build.props` at the root. The tree is compact: `src/` for the engine, `resources/` and `media/` for assets, and two directories that look like separate projects pulled in as submodules, `bang` and `gum`. A `.gitmodules` file at the root confirms that reading. Those two names matter because the README points you at the Bang documentation to understand how the ECS model actually works, which tells you the engine is a thin layer over a framework that carries most of the design weight.

## Why there is no editor executable

The architecture diagram in the README is the whole argument in one block.

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

The point the author draws out immediately after is that there is no external editor executable, only your own project. The stated benefit is full control of your project, and the comparison drawn is to what you would expect from a MonoGame or FNA project.

The reasoning underneath is that editor code and game code should not share a binary. Splitting them into a `game` project and a `game.editor` project means the editor can do whatever it needs, including using heavier dependencies and running tooling, without those dependencies leaking into the shipped build. The `bin` directories sitting side by side under each project show what that buys you: a final game output and an editor output, produced from one project tree, with no third application to install.

The `packed` directory under the game project is the one entry the README does not explain, and it sits next to `bin` in a way that suggests it holds the cooked asset bundle rather than raw resources.

## Built on FNA, targeting desktop platforms, and skipping the web

Murder sits on FNA, the open source reimplementation of Microsoft's XNA framework, and the repository topics list `fna` first alongside `game-engine`, `gamedev` and `multi-platform`. That lineage is worth understanding because it fixes the limits of the engine before you write any code. FNA targets desktop runtimes, so the platform story follows from the foundation rather than from a series of decisions the engine author made later.

The README is specific about what is supported for development: Linux, MacOS, Windows, and Steam Deck. All that is required is the .NET 8 SDK. That is a short and welcome requirements list for an engine, since it means the barrier to running the editor is the runtime and nothing else.

For shipping, the engine targets Linux (which includes Steam Deck), MacOS and Windows, with console support described as in progress. The web and mobile answer is a flat no, stated with an apology: there are no plans to officially support the web or iOS or Android. For a pixel art engine that is a defensible scope boundary rather than a gap, and knowing it before you design the project saves an expensive conversation later.

The repository was last pushed on 2026-09-23, so it is well inside a recent activity window. The project carries 3,327 stars and 97 forks with 16 open issues.

## Learning it through example projects instead of documentation

The README does not attempt a tutorial. Instead it recommends starting with one of two sample projects, a game jam project called Neocity Express or a Hello World project called HelloMurder, and says these show what to expect from the Murder architecture and how to create a world, entities and components.

There is a small piece of self-awareness in the README about this. The author notes that the Hello World project references the Murder repository as its documentation source, then adds a parenthetical acknowledgement that this is redundant. The practical effect is that the two projects and the engine source form one continuous reference: you can read a piece of engine code, find where the sample uses it, and see the result.

That approach only works because of the ECS commitment. A world, entities and components is a small vocabulary compared with the object graphs a typical MonoGame project accumulates, and the author frames the whole engine as being about that vocabulary, which is why the Bang documentation is the recommended next stop rather than any page inside this repository.

Contributing is described in one short paragraph, and it sets expectations plainly. The project is early, and the author invites contact directly or through a linked contributor, saying they are interested in people trying it out and in feedback. There is a Discord badge in the README header for that.

## What the repository shows about its own priorities

The asset side of the tree is where a pixel art engine spends its effort, and it is more prominent than a quick look suggests. Alongside `src/` there is a `resources/` directory at the root and another `resources/` directory inside each of the game and editor projects, plus a `media/` directory holding the logo and editor screenshots shown in the README.

Those editor screenshots are the closest thing to a feature list in the whole document. The README presents three images under an editor examples heading rather than describing the tools in text, which for an engine at this stage is a reasonable choice, since a picture of the editor communicates layout in a way a paragraph would not.

The license is MIT and the language is C#, both of which are what you would expect given the FNA lineage. There are no tagged releases in the repository data, which is consistent with the submodule distribution model: the engine's history lives in its commit log rather than in a versioned package feed.

What you cannot learn from this repository is anything about performance, because the README makes no claims about it at all. There is no benchmark, no profiling guidance, and no discussion of what frame budget to expect. The warning block's promise that things are not perfect yet covers that silence honestly, but it does mean you will be finding out how the engine performs by using it.

## Conclusion

Murder makes two architectural bets that explain everything else about it. The first is that the editor belongs in the game project rather than beside it, which keeps editor code from ever touching your game loop and gives you control over the build output. The second is that an ECS framework and an immediate mode UI library deserve to be separate repositories, which is why Bang and Gum appear alongside the engine source. If you can accept an engine that arrives as a submodule, changes often, and asks you to learn its ECS model before it asks you to draw anything, the payoff is a small C# codebase with a clear place for every file. Start from the Hello World project rather than the source tree, because the author says explicitly that the examples teach the architecture faster than the documentation does.

## FAQ

### How do you install or reference the Murder engine in a project?

There is no NuGet package. The documented approach is to keep a git submodule that references the Murder repository and point your .csproj at it, with the Hello World project linked as a working example of that wiring.

### Does Murder have a separate editor executable like other game engines?

No. The editor is a second project inside your own project tree, alongside the game project, so you get an editor binary without installing a third application. The stated benefit is full control of your project and keeping editor code out of your game build.

### What platforms can a Murder game target?

Linux (including Steam Deck), MacOS and Windows, with console support in progress. The engine explicitly has no plans to support the web or mobile, so iOS and Android are out of scope. Developing requires only the .NET 8 SDK.

### What is Bang and how does it relate to Murder?

Bang is the framework Murder is built on, and the README points at its documentation for understanding how the ECS model applies to the engine. The repository tree carries bang and gum as submodules alongside the engine source, which is why the architecture leans on those two projects.

### Is Murder stable enough for a commercial game?

The README calls it an in-development engine that will change quite a lot, warns against expecting stability, and asks you to proceed at your own risk. It does commit to keeping release branches stable, so pinning a submodule to a release branch gives you a moving target with some structure.

## Sources

- [isadorasophia/murder on GitHub](https://github.com/isadorasophia/murder)
- [Issues](https://github.com/isadorasophia/murder/issues)
- [License: MIT](https://github.com/isadorasophia/murder/blob/main/LICENSE)
- [Project website](https://isadorasophia.com/murder/)
- [README](https://github.com/isadorasophia/murder/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/isadorasophia-murder