I've seen a lot of discussion lately about AI being used in game development, especially with projects like ours and OpenNV. I figured I'd share how we're using it, what we're actually building, and where G.A.R.D.E.N. currently stands.
What is G.A.R.D.E.N.?
G.A.R.D.E.N. is our open-source project focused on rebuilding the engine systems needed to run Fallout 4 content in Godot.
We're not running the Creation Engine inside Godot or modifying Bethesda's original executable. We're building our own implementation using C# and a custom version of Godot that we compile from source.
Our goal is to bring Fallout 4 content into a modern, open-source engine that gives developers and modders more control over how everything works.
We're also working toward compatibility with Fallout 4's existing data formats, plugins, scripts, and mods wherever possible.
Our team and how we use AI
Our team consists of game developers, software developers, and visual artists, all working on different parts of the project.
AI is also part of our development process, just like the other tools we use.
AI is already being used across the software industry, including at major game studios. Whether it's helping with programming, debugging, testing, asset workflows, or development tools, it's becoming a normal part of how software gets built.
We use several AI models throughout development for code assistance, debugging, reviewing implementations, writing regression tests, researching technical problems, and documentation.
It allows us to work through certain tasks much faster, especially when dealing with the amount of code and systems involved in a project like this.
But using AI doesn't change the actual engineering requirements. The code still needs to compile, the systems need to work together, and the results need to be tested.
For example, rebuilding Papyrus isn't just about generating C# code. We need to understand how the original scripting system behaves, implement the required functionality, and verify it against real scripts and game data.
We also use automated testing, regression tests, and code reviews throughout development. Having something pass a test is useful, but the real goal is getting everything functioning correctly together in the engine.
For us, AI is simply another development tool that helps us make progress.
How G.A.R.D.E.N. works
We maintain our own version of Godot, compiled from source with double-precision support and C# integration.
Most of the Fallout-specific systems are written in C#, while Godot handles things like rendering, physics, and other engine functionality.
Instead of distributing Bethesda's original game files, our tools work with the files from your own Fallout 4 installation.
The conversion pipeline processes meshes, textures, materials, and other assets into formats Godot can use. Worldspaces and cells are converted into scenes, while ESM and ESP plugins are read to reconstruct the game's world and records.
We're also rebuilding the Papyrus virtual machine so the original scripts can eventually execute without Bethesda's runtime.
The idea is to preserve compatibility with existing Fallout 4 content while giving developers access to the underlying engine systems.
What we've been working on
There are several major parts of the project currently in development.
World Streaming
One of the first major systems we worked on was world streaming.
Instead of loading large portions of the world all at once, the engine dynamically loads and unloads cells as the player moves through the environment.
We've already tested larger active cell ranges than vanilla Fallout 4, including a 7x7 cell area compared to vanilla's typical 5x5.
We're also working toward seamless interior transitions, where interiors can be loaded in the background before the player enters them.
Papyrus Scripting
This is one of the largest parts of the project.
Fallout 4 uses Papyrus for quests, object interactions, gameplay logic, and many other systems.
We're building our own Papyrus virtual machine, including script execution, native functions, events, and integration with our engine systems.
We're also developing a conversion and caching pipeline for scripts so they don't need to be processed every time the game starts.
Our goal is to support the original game's scripts and existing mod scripts without requiring everything to be rewritten manually.
Modding Framework
Modding is another major focus.
Since our engine is open source and most of the gameplay systems are written in C#, developers can work directly with the engine instead of relying on executable hooks or memory injection.
F4SE DLL mods won't run directly because they're built specifically for Bethesda's engine, but their functionality can be recreated through our engine and modding APIs.
We're also developing tools for user interface customization, making it easier to build and modify interfaces without needing to reverse engineer the original UI systems.
The long-term goal is to make modding more accessible while giving experienced developers much more control.
Where the project currently stands
G.A.R.D.E.N. is still in active development.
We have working conversion tools, world streaming, rendering functionality, and several engine systems already implemented or undergoing testing.
However, we're not at the point where Fallout 4 is fully playable from beginning to end in our engine.
There is still work to be done with Papyrus compatibility, gameplay systems, AI, animations, quests, and getting everything properly integrated.
A system working independently also doesn't mean the entire game is ready. A lot of our work right now involves connecting those systems and making sure they behave correctly with actual Fallout 4 content.
We're continuing to share screenshots, technical demonstrations, and development progress as more features become available.
Why we're building this
I've spent a lot of time working with Fallout 4 mods, F4SE, and reverse engineering, and one thing that becomes obvious is how much effort goes into working around the limitations of an engine we don't have source access to.
That's one of the main reasons we started G.A.R.D.E.N.
With an open-source engine, we can actually change the systems responsible for those limitations.
Want to change how the world streams? You can modify that system.
Want to build a completely different user interface? You can.
Want to add new gameplay mechanics or change how existing systems behave? You have access to the engine itself.
Instead of spending time figuring out how to hook into a closed-source executable, developers can work directly with the systems they want to change.
We also want the project to be useful beyond just Fallout 4. The tools, engine improvements, and frameworks we're building can potentially benefit other projects using Godot.
What's next?
Right now, we're focused on continuing Papyrus compatibility, improving rendering and world streaming, and connecting more of the gameplay systems together.
We're also working toward more complete in-engine demonstrations so people can see how everything functions beyond individual tests and screenshots.
The project is open source, and we're always interested in talking with other developers, modders, artists, and anyone working on similar technology.
If you're interested in contributing, following development, or just learning how everything works, feel free to join the community.
A quick note about Bethesda content
G.A.R.D.E.N. is an independent, community-developed project and is not affiliated with, sponsored by, or endorsed by Bethesda Softworks, ZeniMax Media, or Microsoft.
We do not distribute Bethesda's original game assets. Our tools are designed to process content locally from a user's own legally obtained copy of Fallout 4.
Our goal is to develop an independent, open-source engine and modding framework while respecting the rights of the original creators.
Thanks to everyone who's been following development so far. We're looking forward to sharing more as the project progresses.