🗺 Godot Languages Support

A community-maintained list of Language Support Projects for Godot Engine.

⚠ Disclaimer

The engine and modules are developed in C++. For those topics, please start with the official docs for contributing to the engine and understanding engine development.

In contrast, the languages provided here are for making scripts in Godot projects. Godot has many methods for granting language support:

• Modules: Maintainers/Developers define custom implementations of Godot's Script, ScriptInstance, and ScriptLanguage types in a module. Users add the module to the engine source code and compile the engine themselves (or a developer may provide precompiled binaries). Now you have a new built-in language.
• PluginScript: Maintainers/Developers write an EditorPlugin addon which teaches the Editor how to understand the target language as a ScriptLanguage. Users should only need to download the addon. Powered by Godot's GDNative C interface module.
• NativeScript: Maintainers write tools to generate and build "bindings" in the target language. Developers use the tools to create bindings, write scripts, and compile them into a native library for an addon. Users download the addon and use the native scripts in their projects. To write custom functionality, most people are both Developers and Users. Powered by Godot's GDNative C interface module.
  • Note: The Developer role's complexity is dependent on the quality of the Maintainer's tools. As such, it is language-dependent. Usually, they are difficult. Your mileage may vary!

Categories

By editor support

• 🧬 Can be edited inside Godot Engine (includes language bindings which use PluginScript and the Script API).
• 🔌 Can be edited in an External Editor (includes languages bindings which use NativeScript).

By maintainer

• 💍 Official
• 👥 Community-maintained

By method

• ⚙️ Module
• 📜 PluginScript
• 🔧 NativeScript
• 🏄 "Surfs" on an existing language's functionality to work with Godot.

🏆 Full support

1. GDScript 💍 🧬 🔌 ⚙️

   GDScript is actively maintained and documented and is stable. It is the primary language, has the most tutorials online, and has deep in-Godot editor support.

2. VisualScript 💍 🧬 ⚙️

   VisualScript can be considered as a secondary scripting language with blocks-and-nodes. It too provides rich support, although there is a community effort to make it more intuitive to use as a design tool instead of what users describe as a one-to-one mapping of code with terse programming jargon where it should be more humanized.

🥇 Production Ready

These languages are documented and stable. Some people use these in production.

1. Rust 👥 🔌 🔧

   You can find the project homepage here.

2. Nim 👥 🔌 🔧

   Nim has standard NativeScript features for the moment, but wishes to go beyond that by improving its user experience to automate repetitive boilerplate tasks.

3. C# 💍 🔌 ⚙️

   C# support is an official module. If you have a Mono-version of Godot Engine, it comes built into the engine. Most people are using the VSCode extension.

4. JavaScript 👥 🔌 ⚙️

   JavaScript support is a 3rd-party module. Modules add built-in support (like GDScript) but require compiling it into the engine. With JavaScript, you also get support for languages that transpile to JavaScript, like TypeScript or CoffeeScript and F# Fable.

5. Lua 👥 🧬 🔌 ⚙️

   Lua is currently undergoing a rewrite of its parser.

🥈 Nearly There

Stable and not documented yet.

1. D 👥 🔌 🔧

   Maintained by Sheep. Available in the official Discord channel. It is feature complete, performant and pretty much without any documentation.

2. Haskell 👥 🔌 🔧

   Maintained by the SimulaVR folks. Feature complete and undocumented.

3. Clojure 👥 🔌 🏄

   Based on Mono. No API documentation. Usable and community supported.

🥉 Has Potential

In active development, comparable to being in beta stage.

1. Python 👥 🧬 🔌 📜

   Python is the language for which PluginScript, the API that provides Godot-editor support, got designed for. It provides editor integration as GDScript does - it's still in beta. Currently, the bottleneck to its stability is its flawed export system. PyCharm is another way of doing Python for Godot, and this one supports visual debugging

2. Kotlin JVM 👥 🔌 ⚙️

   Currently in Pre-Alpha. Incomplete, but with documentation and good performance characteristics. Their Discord is nice and friendly.

3. F# 👥 🔌 🏄

   With C#, you also get support for integrating other Mono-supported languages, e.g. F# or VisualBasic. But, Godot currently hardcodes C# usage. Any class attached to a Node or Resource must be a C# script. For tools to facilitate the use of F# with Godot's C# scripts, see Godot F# Tools.

4. Go (godot-go) 👥 🔌 🔧

   Go bindings from godot-go are a recent project in alpha. There is decent documentation of the build workflow and example scripts. It is actively being developed.

🏅 Okay, I guess?

Potential skub.

1. C++ GDNative support 💍 🔌 🔧

   C++ is a bit of a hot potato anywhere, and it is here as well: some people like to use it, but it could use better documentation in places. Some peeves such as not being able to use modern C++ features starting from C++11 dwell in this API.

🐣 Up and coming

Comparable to being in alpha stage.

1. Ada 👥 🔌 🔧

   This isn't documented or (probably) stable, but it is still very new.

2. Dart 👥 🔌 🏄

   Uses Godot's C# API to make calls to Dart script code. Has code for generating scripts.

3. Smalltalk 👥 🔌 🏄

   Pre-alpha, features added daily. Uses a custom C# VM to interpret arbitrary bytecode from a Pharo Smalltalk library. Cuis Smalltalk support planned. Discord server available.

Left 4 Dead

1. Go (ShadowApex) 👥 🔌 🔧

   Go bindings from ShadowApex haven't been updated since 2018. Not documented or stable enough for production.

2. Kotlin Native 👥 🔌 🔧

   Kotlin Native bindings are declared unready for production use and deprecated due to performance problems. Although, it was feature complete at the time of the drop. Here is the old documentation of it.

3. Ruby 👥 🔌 🔧

   Ruby bindings haven't been updated since 2018. It's an attempted PluginScript system, but it's designed poorly with ~15x performance loss vs. GDScript. Not documented or stable enough for use.

4. Haxe 👥 🔌 🔧

5. AngelScript👥 🔌 🔧

   AngelScript was @Geequlim's first forray into GDNative, before making the ECMAScript bindings.

6. Zig 👥 🔌 🔧

7. Object Pascal 👥 🔌 🔧

Other Useful links

• Gamesfromscratch made a video about some of the supported languages.
• (You can expand this list!)

Enjoy ^-^