I discussed with some in the Godot team and we agreed that it's cool if I continue to develop my fork and then in my own time I can try to get in some PRs. So that's the plan:
1. I'll continue to push things in my own fork for webgpu/ nanite/ SDFGI/ HDGI/ HDDAGI improvements and more
2. then over time I'll get some PRs in to Godot mainline
This is the best of both worlds.
I'm planning on increasing performance, adding more features, more tests, more stability.
The next big announcement for this fork will come next week. This will be a release that people can try easily without downloading the engine..
Buckle up because both this Godot fork is not stopping! ๐
Should I keep my Godot fork as separate or try to merge?
TLDR: probably going to keep it as a fork (read below) but please let me know if you have an opinion.
I've been thinking about this for a long time.
I've implemented:
1. Godot WebGPU: mobile and forward renderers (strong beta level - 2months of work)
2. Godot nanite prototype: gpu driven renderer for opaque, transparency and lighting coming soon (<1 week to prototype, probably needs another 2 week to get to strong beta-level)
These are huge Godot changes. Tens of thousands of lines of code.
With effort I'm confident I could get webgpu merged.
But on nanite: Juan Linietsky (the original creator of Godot) has said explicitly that he doesn't support visibility buffers as a viable GPU driven rendering path for Godot (I use visibility buffers in my implementation). Visibility buffers are way better than what he proposes, but among other reasons, the issue is they won't work on Godot's compatibility renderer. So it's probably almost guaranteed that the Godot team won't accept the Godot-nanite changes (I also rewrite a bunch of the core shaders to get it working). I'm not mad about it. I understand why they won't. I'm just stating the facts.
Why do we need the compatibility renderer? for 2 big reasons:
1. some older hardware (e.g. 2015 and before)
2. web
But WebGPU doesn't use the compatibility mode anyway. ~83% of browsers now support WebGPU with a few caveats. Chrome and safari support it. Threejs made webgpu their default renderer and many others are moving on to webgpu. It's here.
The whole point is we are now in the future. AI is helping us develop games, it's helping us develop engines, making them faster, making them better. Maybe 5 years ago the compatibility renderer still mattered but with webgpu and time, it's probably less than 5% of godot game users if not less: just ones using really old android devices and that use firefox on linux. Apple devices are there, newer android devices are there, new desktops are all there, and almost all browsers are there.
How can I possibly succeed at this??
Using AI to not just develop but test the engine fork. I've already done this extensively. I have an extensive set of tests that run the changes on many scenes, and I keep adding scenes. I've added unit tests and I've added fuzz test, and I'm just getting started. No hate to the Godot team, but I don't understand how they've made it this far with the minimal CI (continuous integration) pipeline that they have right now. AI development for something as complex as an game engine is only viable with extensive tests, but that's not an issue. You can and likely should spend 20% of your tokens developing features and 80% testing and verifying features. In my case, the 80% has been automatic as I develop features because as I develop, things don't work, so I add tests to get them working, then I keep the tests and the working features at the end. AI driven development is both the train and the train tracks, vs human development is like riding a bike. It has risks, but ultimately AI driven dev is here.
I have a choice:
1. put in months of extra effort to convince the Godot team to get my PRs reviewed, verified, and merged
2. continue to improve my testing suite for the fork so it's basically undeniably working, I have AI review the code over and over, I have it continue to improve the testing suite, laying down the tracks, then the AI choo choo train chugs along.
3. I do nothing and someone does (2.) anyway.
Godot, Unity, Unreal, all of them are DONE within 5 years if they refuse to use AI. Seems like Unreal and Unity are trying but they're too big and are too averse to changing legacy code. We have a chance to move forward into the future. We can choose to have better performing game engines, extensive and legendary testing suites.
On top of this: Godot has 3 renderer levels:
1. compatibility: OpenGL, essentially legacy at this point
2. mobile: tile-based rendering in a single rendering pass, lacks fancy lighting features
3. forward fancier AAA-level features for lighting and more.
If I move forward with this fork, my plan is to:
1. remove the entire compatibility renderer which is about 50% of the Godot codebase!
2. merge the mobile and forward renderers so there's only 1 renderer. And developers simply choose their feature set without choosing their renderer: this also removes another ~10% of the engine's code
Then what we are left with:
- Single renderer forward-merged
- WebGPU for web
- GPU Driven renderer (nanite) huge performance benefit
- Improvements to global illumination that I haven't talked about in this post yet
- huge testing suite improvements to prevent regressions moving forward
- AI-driven development momentum that will not stop ๐
- Most Godot projects will still work in this fork that use the mobile or forward renderers.
With all of this, I think the best decision is to keep a fork of Godot and move forward. If the Godot team wants to use any of my improvements, they are very welcome to but if they aren't on board with my AI driven development strategy then that's totally fine and I think them for being the giant shoulders that I can stand upon.
With that in mind, I can be convinced either way so
Please comment below if you think I should or shouldn't keep a fork of Godot or if you have any other ideas related to this!