# Dalamud: the plugin host that injects itself into Final Fantasy XIV > Dalamud is the plugin framework for Final Fantasy XIV, a mixed C++ and C# system that loads a .NET runtime into the game process and exposes game data, chat and overlays to plugins. It is installed and managed by XIVLauncher rather than by hand, and it asks that no generative AI contribute code to it. **goatcorp/Dalamud** — FFXIV plugin framework and API - Repository: https://github.com/goatcorp/Dalamud - Stars: 1,643 · Forks: 389 - Language: C - License: AGPL-3.0 - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/goatcorp-dalamud ## A plugin framework for one specific game Dalamud is a plugin development framework for Final Fantasy XIV that provides access to game data and native interoperability with the game itself, in order to add functionality and quality of life. The audience is narrow by design: a developer who wants to write a plugin for that game, and who would otherwise be reverse engineering a proprietary client to find out where the party list lives and how to draw a window on top of it. The README is careful about who the other audience is. It says Dalamud is meant to be used in conjunction with XIVLauncher, which manages and launches Dalamud for you, and that it is generally not recommended for end users to run Dalamud manually, because XIVLauncher manages multiple required dependencies. There is a Hold Up section that repeats the point: if you are just trying to use Dalamud, you need to do nothing on this page, and should download XIVLauncher from its official page and follow the setup instructions. So there is a clean split. Players install a launcher, developers read the API documentation and the developer FAQ, and the repository is for the second group. ## The injection pipeline, component by component The most useful thing in the repository is the components table, which lists the pieces used in order to load Dalamud into a target process, and the sentence that introduces it: Dalamud can be loaded via DLL injection, or by rewriting a process' entrypoint. The chain runs like this. Dalamud.Injector.Boot, in C++, loads the .NET Core runtime into a process via hostfxr and kicks off Dalamud.Injector. Dalamud.Injector, in C#, then performs the DLL injection on the target process. Dalamud.Boot, in C++, loads the .NET Core runtime into the active process and kicks off Dalamud, or rewrites a target process' entrypoint to do so. Dalamud itself, in C#, is the core API, the game bindings and the plugin framework. The fifth component, Dalamud.CorePlugin, is a testbed plugin that can access Dalamud internals, which exists to prototype new Dalamud features. The design is worth understanding because it explains the shape of the tree, with separate directories for Dalamud.Boot, Dalamud.Injector, Dalamud.CorePlugin, Dalamud.Common, Dalamud.Test and DalamudCrashHandler, and it explains why a plugin developer never touches the injection code at all. ## What a plugin actually gets The plugin surface is described as a growing API for in-game plugin development with game data and chat access and overlays. Those three nouns are the whole contract with the game, and they are the reason Dalamud exists as a project rather than a set of scattered overlays. Game data access means a plugin can ask the framework what is on the party list, what the player's state is, or what the interface is currently showing, rather than hardcoding offsets into client memory and hoping a patch does not move them. Chat access means a plugin can read and respond to the game's chat channels. Overlays mean a plugin can draw its own windows, which is what most quality-of-life plugins are actually made of. The API is documented at dalamud.dev, and there is a developer FAQ at goatcorp.github.io for support on the API and its usage, with a Discord server as the support channel. The word growing in the description is a warning as much as a boast: the API surface changes as the game does, so a plugin written against one version of Dalamud can break on the next, which is the operational cost every plugin author absorbs. ## Building it is a local dependency hunt There is no install command to copy from the README. The building and testing instructions live on a docs page at dalamud.dev/building, which the README points to for more information and required dependencies, and that is where you start. The tree shows what that involves. There is a CMakeLists.txt and a CMakePresets.json for the native side, a build.cmd for the Windows build, a generate.cmd for the code generation step, and a generators/ directory that presumably produces the generated sources. The managed side uses the modern .NET layout, with Directory.Build.props, Directory.Packages.props for central package versions, a global.json pinning the SDK, Dalamud.slnx as the solution, and a docfx.json for the API documentation build, which is what produces the site the developers are sent to. There is a stylecop.json for the C# style rules and an .editorconfig. Several vendored trees sit in external/, lib/ and shared/, with imgui/ providing the immediate mode GUI library the overlays are drawn with, and .gitmodules indicating the submodules are fetched separately. The presence of a DalamudCrashHandler/ directory and a Dalamud.Test/ directory tells you the project has a crash handler of its own and a test project, and the filterConfig.yml and tools/ directories suggest the native build has a filtering step for the modules it links. ## The repository asks that no AI write its code One section of the README is unusual enough to call out on its own, because it is a policy a reader has to know about before deciding what to do with the project. The AI and LLM authored contributions section states that Dalamud and XIVLauncher do not accept contributions made using generative AI, and it kindly asks that you do not interact with this repository using automated systems driven by LLM or AI tools. That is a policy about contributions and about repository interaction, not a prohibition on writing about the software, and this article is a description of what is in the repository rather than a change to it. But the practical consequence for a developer is real: a patch generated by a model will not be merged, and a contributor working with an automated tool is unwelcome here. For an evaluator this cuts both ways. It is a signal that the maintainers consider the codebase fragile enough, or the review burden high enough, that they want human authorship and human review for every change. It also means the growth of the ecosystem depends on a pool of human contributors, which is a constraint on how quickly the API can extend to new game features. The project does credit Mino, whose work made it possible, and the trademark note states that Final Fantasy XIV is copyright Square Enix and that the project is not affiliated with Square Enix in any way. ## Where Dalamud is the wrong tool The limits are structural. First, it is bound to one game, and every component, from the game bindings to the chat access, exists to serve that one title, so none of it transfers to another game or to a general purpose in-process plugin system. Second, the mechanism is injection. The framework loads a runtime into a running process and either injects a DLL or rewrites the process entrypoint, which means the alternative approach, a separate overlay process that reads the client's state without injecting into it, is architecturally different and outside this project's scope. That alternative avoids injection entirely, which some users prefer for stability, at the cost of giving up the in-process API, the chat access and the overlay framework that plugins rely on, and it means writing your own offsets and your own update handling. Third, the coupling to the game's patch cycle is total. The API is described as growing, and it grows because the game changes, so the ecosystem has to be reworked every time Square Enix ships. Fourth, this is a client modification framework for a game with terms of service, and the README is explicit that the project is not affiliated with the game publisher. Fifth, the licence is AGPL-3.0, which is a real consideration for a team that might otherwise prefer to keep a plugin closed. ## Conclusion Adopt Dalamud if you are writing plugins for Final Fantasy XIV and want the game's data, chat and overlay services through a maintained API rather than by reading process memory yourself. Do not adopt it for any other game or for a general purpose in-process plugin system, because every component is tied to one title, and do not expect end users to install it by hand, since XIVLauncher manages it. Before you start, read the building page for the dependency list, and note the project's stated refusal of generative AI contributions, which means a patch you generate will not be accepted upstream. ## FAQ ### What is Dalamud? Dalamud is a plugin development framework for Final Fantasy XIV that provides access to game data and native interoperability with the game itself, so plugins can add functionality and quality-of-life. The API covers game data, chat access and overlays. ### How do end users install Dalamud? They do not install it manually. The README says it is generally not recommended for end users to run Dalamud manually, because XIVLauncher manages multiple required dependencies, so users should download XIVLauncher from its official page and follow the setup instructions. ### How does Dalamud get loaded into the game? The components table says Dalamud can be loaded via DLL injection, or by rewriting a process' entrypoint. Dalamud.Injector.Boot loads the .NET Core runtime via hostfxr, Dalamud.Injector performs the DLL injection, and Dalamud.Boot loads the runtime and starts Dalamud or rewrites the entrypoint to do so. ### Does Dalamud accept AI-generated contributions? No. The README states that Dalamud and XIVLauncher do not accept contributions made using generative AI, and asks that you do not interact with the repository using automated systems driven by LLM or AI tools. ### What licence is Dalamud released under? The project is licensed under AGPL-3.0, with the LICENSE file at the repository root. The latest listed release is v14.0.4.0 from 2026-03-10 and the last push was on 2026-10-18. ## Sources - [goatcorp/Dalamud on GitHub](https://github.com/goatcorp/Dalamud) - [Issues](https://github.com/goatcorp/Dalamud/issues) - [License: AGPL-3.0](https://github.com/goatcorp/Dalamud/blob/master/LICENSE) - [README](https://github.com/goatcorp/Dalamud/blob/master/README.md) - [Releases](https://github.com/goatcorp/Dalamud/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/goatcorp-dalamud