Are there feature/performance/platform limitations when using the Mono/C# version of Godot?

Question

I've read through the Godot page about differences between the C#/mono version and the standard version (gdscript), and it primarily seems to be focused on the fact that C# is a different language with different conventions, and that support is a new feature that may have issues. It doesn't really seem to discuss any different capabilities or features gained or lost by using one version vs. the other.

The drawbacks of using the Mono/C# version seem to be:

• There are likely some bugs because it is a new feature
• If you don't already know C#, you need to learn (as with any language)

Are there different features, performance implications, or platform support limitations when using C#?

Answer 1

There are likely some bugs because it is a new feature

C# - the language - is well supported. Also, a lot of effort have gone into supporting ahead of time compiling, which allows greater platform support than it would have otherwise. However:

• Some .NET libraries may cause trouble (mainly related to threading and reflection).
• It is not well integrated into the editor. At least not at the time of writing. So I'd advice to use an external editor such as Visual Studio Code with C# Tools for Godot.

---

If you don't already know C#, you need to learn

The same can be said of GDScript. In fact, given that other engines also use C# - but not GDScript - you probably have an easier time transfering knowledge using C# (and even entire classes, if they don't have engine specific code). But don't let that discorage you form learning GDScript.

---

For someone who is comfortable working with both gdscript and c#, what are the reasons for choosing one version of godot over the other?

Some C# cons:

• Using C# your build will be somewhat heavier.
• We can be sure that everybody using Godot can use GDScript. Thus GDScript is the language of choice for addons. Going to C++ if we want to squish more performance, or if we need to talk to native code.
• Metaprogramming is easier with GDScript: you crate a GDScript object with some code, then load it, instance it and run it. With C# you would need reflection for something like that, but it may not work, in particular with platforms that need ahead of time compiling.

Some C# pros:

• You will have access to a larger set of libraries (with some caveats, as I said earlier, some cause trouble).
• GDScript - prior to Godot 4 - is an interpreted language. And also C# is fully typed. As a result, C# often performs better than GDScript.
• C# has some language features that make it easier to use compared to GDScript (e.g. iterators, lambda functions).

---

For everyday use, either is OK - so you can go with personal preference. However, when you get into very specific uses (e.g. metaprogramming, addons) or when you need some extra performance, that may tip the balance one way or the other. You may - of coruse - not know if you will run into those situations ahead of time.

On that note, I want to mention that you can combine both in the same game. So don't decide between them too early. In fact, using GDScript to deal with signals and have it call into C# code for game logic, might be a good idea. Since GDScript is a great glue language, and C# can archive better performance.

However, sometimes the interaction between these languages is not that smooth. For instance, async methods in C# - often - returns a Task and GDScript can't handle that with yield. For those situation, you want to refactor the code to use signals instead of async methods.

And - by the way - you can combine any other language you have in Godot, including visual scripting, and third party languages that you can install into Godot such as Lua and Python and so on. And yes, C++.

Answer 2

There is like a Godot world and .NET/Mono world (.NET for Godot 4 and Mono for Godot 3). Godot world runs your scenes and nodes, .NET/Mono runs your scripts when using C#. GDScript scripts are apparently better at communicating with this Godot world, than C# scripts (C# carries additional cost or so I heard). On the other hand the scripts themselves in C# might be faster (especially if you want to run some complex simulation/computation). C# also gives access to many convenient libraries.

However C# can introduce some confusion and not so obvious bugs. When you write your scripts in GDScript, you are limited to doing things the Godot way. When you write in C# you can still do things the Godot way, but .NET/Mono way of doing things become available (which you might want to do if you are familiar with the language/framework). Not everything translates 1:1 between those 2 worlds (though a lot of effort went into Godot 4.0 to make the experience more seamless). In C# you might face 2 different ways to declare and emit signals, run async code, read files etc. Sometimes both are fine, sometimes one is wrong and it's not obvious when. In many cases, sticking to the Godot way of doing things might be a better option in the long run, as there is some serious optimization related to managing nodes and scenes on the Godot end and using the .NET/Mono way may cause bugs with the engine. On the other hand if you want to tap some of extra power that comes with .NET/Mono you would have to abandon Godot way of doing something. When coding in C#, you might think "how do I solve this in .NET" and miss that Godot has a built-in function for that already. Some built-in parts of .NET ecosystem refuse to work in a Godot project (I was unable to use ASP for networking, but thankfully Godot has it's own functions for that).

Adding to the mix of pros and cons, in C# it's easier to extend Godot's built-in functions using Extensions and the the like (for when GDScript is missing something). Although some of the things I miss in GDScript work in C# out of the box for Godot (like you can do much more with collections and easier at that). GDScript in Godot 4.0 went a long way from the previous versions, so I expect less things to complain about in future versions of Godot.

With Godot 4.0, Visual Studio integration works really well and preparing the environment for debugging is much easier. C# project structure and solution were also greatly improved (Framework styled project were replaced with the modern SDK style projects and Godot no longer appears to overwrite them which would lead to losing changes made in an external IDE).

Last, but not least, I think it's possible to do a bit of both (C# and GDScript) in your project.