Hacker News Reader

Comment by voodooEntity | Hacker News Reader

Was playing arround recently building an RTS with godot until i just hit the ceilling of what i could handle with gdscript performance wise.

Than started to move alot of heavy logic to c++ simulation : tedious indeed but the results speak for themself.

Basically allows me to use godot for things like menus dialogues and similar stuff while running the true heavy work in a c++ simulation.

View on HN

What motivated you to use c++ rather than C#? Especially when you mention the usage of c++ being tedious, when I would argue using C# is equally straight forward as gdscript is.

C# is a "first class" language in Godot and doesn't need a GDExtension, but it's not compatible with web builds yet. There is a draft PR that includes C# support but it adds about +50 MB to a web export and is also missing a few features.

I did not know that. Thanks for the info. I always use C# with Godot, but never had a use-case where i needed a web build.

And even that doesn't add consoles support, is W4 that far?

Console support is accomplished using "Middleware ports" for the Nintendo Switch, Xbox Series X/S, and PlayStation 5. https://godotengine.org/consoles/

I know the process, the question was how far .NET tooling support is there, because if they just rewrite everything into C++, there isn't much there to talk about.

A combination of two factors that are rather specific to myself. One being that even tho its quite some time ago i have a bit of c++ experience, while i never tried to code C#. So when i got the idea to try to run the heavy simulation in an "extension" it was just a language i was a bit familiar with. Maybe C# would have been the "smarter" choice, i just never digged into it yet.

The other reason is that in my well closer circle i got quite some people that code c++ on a daily basis and i don't know (at least i think so) anyone doin C# actively, so i thought if i would get stuck i have people i can easily ask about my c++ problems.

So it wasn't a "i think c++ is better than c#" decision rather a what do i know and what resources i have available easily.

C# is mostly in the Unity community. I agree that GDScript performance isn't good.

Godot, Unity, Stride, Flax and even jank niche engines like NeoAxis generally have pretty good C# integration!

If you look more at Stride, you’ll see that even their physics engine is C# which is insane in the best possible way: https://doc.stride3d.net/4.3/en/Manual/physics/index.html and https://github.com/bepu/bepuphysics2

Very cool language and as much of a mainstay in gamedev like something like Lua.

It surprises me that Java never got similarly big despite their GC improvements, though jMonkeyEngine was a nice project last I looked.

Yeah there are some gamedev treasures in C#, owning to the fact that Microsoft created the Xbox Live Indie Games program back in the X360 era, which meant you could ship games to customers with generally little oversight and meddling - this was WAY before Steam did something similar, and even before the iPhone app store.

The catch was that you had to use C# and XNA (which was a wrapper for gaming related APIs like DirectX, XAudio and XInput, generally considered to be very good). This meant there were a lot of hardcore libs made for C# gamedev (BEPU physics is from that era, and there were things like very good UI frameworks).

Tons of games were made with XNA, and its open source ofshoots, MonoGame and FNA power some of the greatest indie hits (Stardew Valley, Celeste, Bastion and other Supergiant titles, Terraria come to mind).

Imo this is one of the main reasons Unity went with C# in the first place.

Historical note that Arena Wars, released in the .NET 1.0 days, with thin bindings to OpenGL, was the very first .NET game, years before XNA.

https://en.wikipedia.org/wiki/Arena_Wars

C# being closer to C++, and .NET having direct support for C++ helped quite a bit regarding adoption among game studios.

Unity started on Mac, and they only adopted .NET when doing the cross platform rewrite.

I also don't remember if there wasn't some Mono advocacy at the time, as they became customers in the process.

Ironically Mono/Xamarin is almost gone from official .NET, all these years after the acquisition, with every modern .NET release, another bit falls off.

We are already on the phase that CoreCLR might take the remaining bits.

Not sure how relevant this is for this simulation use case but IIRC C# has a bigger overhead when communicating with the core engine compared to GDScript or C++.

gdscript is incredibly slow, worst than something like lua, maybe only good for handling the UI events

the hierarchy and physics api isn’t great either, it’s easy to hit heap allocs even from a gdextension

a lot of things wrong with this generic engine, but at least it’s lightweight

Lots of things right too, thankfully

Godot is only the best open source engine because Bevy is not ready for production, Lumberyard/O3DE is hard to set up and everything else is ancient or 2D only. one eyed man among the blind type shit

I miss Torque

> Godot is only the best open source engine because Bevy is not ready for production

I would argue that even if Bevy was ready for production it would not really compete with Godot.

Godot's performance is plenty for the vast majority of small to medium games. Plus they're starting to work on features like texture streaming for bigger games. It also has an editor which is a big plus for most teams.

Bevy would be objectively better for expensive CPU simulation stuff but realistically what percentage of games need that? Maybe 1%?

For Bevy to catch up on the indie game scene it needs an editor plus a scripting language and/or something like Unreal Blueprints. If it only wants to target the hardcore Rust dev that does everything by code it will never go mainstream.

No. If you try Bevy, it feels different from ECS and ordinary OOP. So it's hard to get used to. But Godot, although GDScript has performance issues, if you use GDScript it's easy to port to mobile and web games, and the syntax itself is OOP, so it's easy to adapt to.

A lot of people complain about OOP, but it's a paradigm very well suited for rapid development.

Lots of people complain, yet nothing else has won over in GUI development tooling.

Godot is the best open source engine because it is dead simple to use, comes bundled with its own IDE and documentation, the editor runs on any platform that Godot runs (including the web) and the performance benefits for something like Bevy only apply to a handful of games that really need it.

Godot gives GDScript simplicity for the vast majority of use cases which is that iteration boon, provides C# for games that need the additional guardrails. For performance critical game scripts you can just jump to C++, Rust, Swift, etc.

But most game scripts are not performance critical. Clair Obscur: Expedition 33 swept the game awards last year as an Unreal Engine game made using almost entirely visual scripting (blueprints).

Also Unreal C++ has a GC, exactly to have easy interoperability between engine code and C++ components exposed to Blueprints.

It still bothers me that game engines come with their own bespoke languages like GDScript. Godot is a bit better than others for having C# support and forks in other languages but really no other language will ever be as integrated with the framework as GDScript, And GDScript is never going to be a general purpose programming language, and that necessarily creates lock-in.

I'm currently messing with some old projects written in Game Maker 5 and let me tell you it would be so much easier if I didn't have to do internet archaeology just to figure out how GML worked 20 years ago.

Because it is much easier to have a custom language, than try to subsetting an existing mainstream language, while having to deal with all the mess of people trying to use random stuff on the engine, that naturally isn't supported.

Example, see all the bad rep .NET and C# get from devs that only know them from Unity, full of legacy stuff and restrictions, instead of using the real product.

That seems like more of a feature than a bug to me. Using C# in Godot means you have all of the Nuget libraries at your disposal, whereas no one is writing libraries in GDScript, because no one is using it outside of Godot.

Meanwhile to extend Godot usefully you have to use C++ and a plugin API that's arguably no less complicated than adapting an existing language as the scripting language would have been.

But that is the thing, you don't have access to all the NuGet libraries, or even CLR/MSIL abilities, it is a hit and miss depending on what platforms are being targeted.

Sure if you only want to target desktop/laptop computers, you're safe.

I always do not understand why defold is never put into the fold [sic!] of those sentiments/discussions. You can learn a clean & fun language (lua) and its JIT is maybe/probably running laps around something like GDScript, which in itself is proprietary and has no other uses for you than, ehh, Godot?? You can integrate C/C++ extensions natively, neatly exposing them through lua APIs. Its mobile and web target footprint is unbeatably (?) small, desktop at least 10x smaller than Godot or Unity. It is Open Source.

Maybe it's the "ancient" part, because more recent is always better ;)

defold is really cool, the only downside is its really weird build system for native extensions

> I always do not understand why defold

Starting with absolutely nothing but a compiler is always going to be a worse experience (and less likely to result in anything released) than a GUI-driven and aided solution. If Defold developers had produced a fraction of the libraries that Godot has, it might have had a chance. As of now, it's worse than other abandoned engines like Solar2D (was CoronaSDK) for people entering the space. As most people know, the vast majority of games are net-losses, so engines live and die by the ease of adoption by newcomers.

> Starting with absolutely nothing but a compiler

I don't understand what you mean by this -- Defold has a graphical editor?

> If Defold developers had produced a fraction of the libraries that Godot has, it might have had a chance.

What do you mean by libraries in this context? It has a robust plugin system with a reasonably active ecosystem, if that's the sort of thing you're talking about: https://defold.com/assets/

And it covers all the systems one would expect in a 2D game engine natively -- tilemaps, physics etc.

> As of now, it's worse than other abandoned engines like Solar2D (was CoronaSDK) for people entering the space.

I definitely disagree with this -- it's certainly not abandoned, and though it does have a slightly steeper learning curve than Godot or other popular engines, that's also how it gets such impressive performance and slim builds; feature, not a bug.

Unfortunately, I'm really not a fan of using Lua for anything beyond simple scripting.

Good news, they've been working on adding C# support for a year or two now. I think it's still experimental, but from what I understand they already had a robust extension system that supported C/C++/Java/etc., so fitting C# in wasn't much of a stretch.

(it is only extension support -- not scripting -- but the extension system is such that it can be used for any game logic AFAIK)

At which point do you just switch to a cpp UI library and forget about the engine?

It's not like i didn't consider that step :D but as mentioned in another response the game contains some rather complex configurator etc systems that i already completely baked with the godot system, also a simple map editor that works fine - so im not to motivated to also rewrite them all. Apart from that its a hobby project (one of many) so well maybe i reach that point and go full c++ but for now i dont think i will.

Assuming it's a 2D game, why not just use something like SFML to build your own simple RTS engine at that point?

Seems like carrying a lot of Godot baggage around for nothing.

Godot comes with a lot of tools in addition to the runtime. Maybe they are using the IDE to do layouts for the menu dialogues, for example.

Also, I am not sure about how easy it is to build binaries using SFML for various platforms (such as WASM), but with Godot you just have to download the right template.

Again combination of multiple points but for some part this is correct.

One side is that i started developing it with godot, and the game has well alot of menu stuff going on (without wanting to go to much into detail but you are to a certain degree able to configure units outside of a match into "blueprint" like system). This whole editor / management etc stuff got quite big and works really well.

Means, when i hit the gdscript limits, i did not want to port all of the existing stuff that already works perfectly fine with godot.

And ye since the c++ only runs math simulations but i still use the godot renderer (which so far seems to work out perfectly fine) i was okay with that mixed solution (for now).

Reply on news.ycombinator.com