Frequently asked questions (2024)

What can I do with Godot? How much does it cost? What are the license terms?¶

Godot is Free and Open-Source Software available under the OSI-approved MIT license. This means it is free as in "free speech" as well as in "free beer."

In short:

• You are free to download and use Godot for any purpose: personal, non-profit, commercial, or otherwise.

• You are free to modify, distribute, redistribute, and remix Godot to your heart's content, for any reason, both non-commercially and commercially.

All the contents of this accompanying documentation are published underthe permissive Creative Commons Attribution 3.0 (CC-BY 3.0) license, with attributionto "Juan Linietsky, Ariel Manzur and the Godot Engine community."

Logos and icons are generally under the same Creative Commons license. Notethat some third-party libraries included with Godot's source code may havedifferent licenses.

For full details, look at the COPYRIGHT.txt as wellas the LICENSE.txt and LOGO_LICENSE.txt filesin the Godot repository.

Also, see the license page on the Godot website.

Which platforms are supported by Godot?¶

For the editor:

• Windows

• macOS

• X11 (Linux, *BSD)

• Web

• Android (experimental)

For exporting your games:

• Windows (and UWP)

• macOS

• X11 (Linux, *BSD)

• Android

• iOS

• Web

Both 32- and 64-bit binaries are supported where it makes sense, with 64being the default.

Some users also report building and using Godot successfully on ARM-basedsystems with Linux, like the Raspberry Pi.

Additionally, there is some unofficial third-party work being done on buildingfor some consoles. However, none of this is included in the default buildscripts or export templates at this time.

For more on this, see the sections on exportingand compiling Godot yourself.

Which programming languages are supported in Godot?¶

The officially supported languages for Godot are GDScript, Visual Scripting,C#, and C++. See the subcategories for each language in thescripting section.

If you are just starting out with either Godot or game development in general,GDScript is the recommended language to learn and use since it is native to Godot.While scripting languages tend to be less performant than lower-level languages inthe long run, for prototyping, developing Minimum Viable Products (MVPs), andfocusing on Time-To-Market (TTM), GDScript will provide a fast, friendly, and capableway of developing your games.

Note that C# support is still relatively new, and as such, you may encounter someissues along the way. Our friendly and hard-working development community is alwaysready to tackle new problems as they arise, but since this is an open-source project,we recommend that you first do some due diligence yourself. Searching throughdiscussions on open issues is agreat way to start your troubleshooting.

As for new languages, support is possible via third parties using the GDNative /NativeScript / PluginScript facilities. (See the question about plugins below.)Work is currently underway, for example, on unofficial bindings for Godotto Python and Nim.

What is GDScript and why should I use it?¶

GDScript is Godot's integrated scripting language. It was built from the groundup to maximize Godot's potential in the least amount of code, affording both noviceand expert developers alike to capitalize on Godot's strengths as fast as possible.If you've ever written anything in a language like Python before then you'll feelright at home. For examples, history, and a complete overview of the power GDScriptoffers you, check out the GDScript scripting guide.

There are several reasons to use GDScript--especially when you are prototyping, inalpha/beta stages of your project, or are not creating the next AAA title--but themost salient reason is the overall reduction of complexity.

The original intent of creating a tightly integrated, custom scripting language forGodot was two-fold: first, it reduces the amount of time necessary to get up and runningwith Godot, giving developers a rapid way of exposing themselves to the engine with afocus on productivity; second, it reduces the overall burden of maintenance, attenuatesthe dimensionality of issues, and allows the developers of the engine to focus on squashingbugs and improving features related to the engine core--rather than spending a lot of timetrying to get a small set of incremental features working across a large set of languages.

Since Godot is an open-source project, it was imperative from the start to prioritize amore integrated and seamless experience over attracting additional users by supportingmore familiar programming languages--especially when supporting those more familiarlanguages would result in a worse experience. We understand if you would rather useanother language in Godot (see the list of supported options above). That being said, ifyou haven't given GDScript a try, try it for three days. Just like Godot,once you see how powerful it is and rapid your development becomes, we think GDScriptwill grow on you.

More information about getting comfortable with GDScript or dynamically typedlanguages can be found in the GDScript: An introduction to dynamic languages tutorial.

What were the motivations behind creating GDScript?¶

In the early days, the engine used the Luascripting language. Lua is fast, but creating bindings to an objectoriented system (by using fallbacks) was complex and slow and took anenormous amount of code. After some experiments withPython, it also proved difficult to embed.

The main reasons for creating a custom scripting language for Godot were:

1. Poor threading support in most script VMs, and Godot uses threads(Lua, Python, Squirrel, JavaScript, ActionScript, etc.).

2. Poor class-extending support in most script VMs, and adapting tothe way Godot works is highly inefficient (Lua, Python, JavaScript).

3. Many existing languages have horrible interfaces for binding to C++, resulting in large amount ofcode, bugs, bottlenecks, and general inefficiency (Lua, Python,Squirrel, JavaScript, etc.) We wanted to focus on a great engine, not a great amount of integrations.

4. No native vector types (vector3, matrix4, etc.), resulting in highlyreduced performance when using custom types (Lua, Python, Squirrel,JavaScript, ActionScript, etc.).

5. Garbage collector results in stalls or unnecessarily large memoryusage (Lua, Python, JavaScript, ActionScript, etc.).

6. Difficulty to integrate with the code editor for providing codecompletion, live editing, etc. (all of them). This is well-supportedby GDScript.

GDScript was designed to curtail the issues above, and more.

What type of 3D model formats does Godot support?¶

Godot supports Collada via the OpenCollada exporter (Maya, 3DSMax).If you are using Blender, take a look at our own Better Collada Exporter.

As of Godot 3.0, glTF is supported.

FBX is supported via the Open Asset Import library. However, FBX is proprietaryso we recommend using other formats listed above, if suitable for your workflow.

Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Godot?¶

The aim of Godot is to create a free and open-source MIT-licensed engine thatis modular and extendable. There are no plans for the core engine developmentcommunity to support any third-party, closed-source/proprietary SDKs, as integratingwith these would go against Godot's ethos.

That said, because Godot is open-source and modular, nothing prevents you oranyone else interested in adding those libraries as a module and shipping yourgame with them--as either open- or closed-source.

To see how support for your SDK of choice could still be provided, look at thePlugins question below.

If you know of a third-party SDK that is not supported by Godot but that offersfree and open-source integration, consider starting the integration work yourself.Godot is not owned by one person; it belongs to the community, and it grows alongwith ambitious community contributors like you.

How do I install the Godot editor on my system (for desktop integration)?¶

Since you don't need to actually install Godot on your system to run it,this means desktop integration is not performed automatically.There are two ways to overcome this. You can install Godot fromSteam (all platforms),Scoop (Windows), Homebrew (macOS)or Flathub (Linux).This will automatically perform the required steps for desktop integration.

Alternatively, you can manually perform the steps that an installer would do for you:

Is the Godot editor a portable application?¶

In its default configuration, Godot is semi-portable. Its executable can runfrom any location (including non-writable locations) and never requiresadministrator privileges.

However, configuration files will be written to the user-wide configuration ordata directory. This is usually a good approach, but this means configuration fileswill not carry across machines if you copy the folder containing the Godot executable.See File paths in Godot projects for more information.

If true portable operation is desired (e.g. for use on an USB stick),follow the steps in Self-contained mode.

Why does Godot use Vulkan or OpenGL instead of Direct3D?¶

Godot aims for cross-platform compatibility and open standards first andforemost. OpenGL and Vulkan are the technologies that are both open andavailable (nearly) on all platforms. Thanks to this design decision, a projectdeveloped with Godot on Windows will run out of the box on Linux, macOS, andmore.

Since Godot only has a few people working on its renderer, we would preferhaving fewer rendering backends to maintain. On top of that, using a single APIon all platforms allows for greater consistency with fewer platform-specificissues.

In the long term, we may develop a Direct3D 12 renderer for Godot (mainly forthe Xbox's purposes), but Vulkan and OpenGL will remain the default renderingbackends on all platforms, including Windows.

Why does Godot aim to keep its core feature set small?¶

Godot intentionally does not include features that can be implemented by add-onsunless they are used very often. One example of this would be advancedartificial intelligence functionality.

There are several reasons for this:

• Code maintenance and surface for bugs. Every time we accept new code inthe Godot repository, existing contributors often take the reponsibility ofmaintaining it. Some contributors don't always stick around after gettingtheir code merged, which can make it difficult for us to maintain the code inquestion. This can lead to poorly maintained features with bugs that are neverfixed. On top of that, the "API surface" that needs to be tested and checkedfor regressions keeps increasing over time.

• Ease of contribution. By keeping the codebase small and tidy, it can remainfast and easy to compile from source. This makes it easier for newcontributors to get started with Godot, without requiring them to purchasehigh-end hardware.

• Keeping the binary size small for the editor. Not everyone has a fast Internetconnection. Ensuring that everyone can download the Godot editor, extract itand run it in less than 5 minutes makes Godot more accessible to developers inall countries.

• Keeping the binary size small for export templates. This directly impacts thesize of projects exported with Godot. On mobile and web platforms, keepingfile sizes low is primordial to ensure fast installation and loading onunderpowered devices. Again, there are many countries where high-speedInternet is not readily available. To add to this, strict data usage caps areoften in effect in those countries.

For all the reasons above, we have to be selective of what we can accept as corefunctionality in Godot. This is why we are aiming to move some corefunctionality to officially supported add-ons in future versions of Godot. Interms of binary size, this also has the advantage of making you pay only for whatyou actually use in your project. (In the meantime, you cancompile custom export templates with unused features disabledto optimize the distribution size of your project.)

How should assets be created to handle multiple resolutions and aspect ratios?¶

This question pops up often and it's probably thanks to the misunderstandingcreated by Apple when they originally doubled the resolution of their devices.It made people think that having the same assets in different resolutions was agood idea, so many continued towards that path. That originally worked to apoint and only for Apple devices, but then several Android and Apple deviceswith different resolutions and aspect ratios were created, with a very widerange of sizes and DPIs.

The most common and proper way to achieve this is to, instead, use a singlebase resolution for the game and only handle different screen aspect ratios.This is mostly needed for 2D, as in 3D it's just a matter of Camera XFov or YFov.

1. Choose a single base resolution for your game. Even if there aredevices that go up to 2K and devices that go down to 400p, regularhardware scaling in your device will take care of this at little orno performance cost. Most common choices are either near 1080p(1920x1080) or 720p (1280x720). Keep in mind the higher theresolution, the larger your assets, the more memory they will takeand the longer the time it will take for loading.

2. Use the stretch options in Godot; 2D stretching while keeping aspectratios works best. Check the Multiple resolutions tutorialon how to achieve this.

3. Determine a minimum resolution and then decide if you want your gameto stretch vertically or horizontally for different aspect ratios, orif there is one aspect ratio and you want black bars to appearinstead. This is also explained in Multiple resolutions.

4. For user interfaces, use the anchoringto determine where controls should stay and move. If UIs are morecomplex, consider learning about Containers.

And that's it! Your game should work in multiple resolutions.

If there is a desire to make your game also work on ancientdevices with tiny screens (fewer than 300 pixels in width), you can usethe export option to shrink images, and set that build to be used forcertain screen sizes in the App Store or Google Play.

How can I extend Godot?¶

For extending Godot, like creating Godot Editor plugins or adding supportfor additional languages, take a look at EditorPluginsand tool scripts.

Also, see the official blog posts on these topics:

• A look at the GDNative architecture

• GDNative is here!

You can also take a look at the GDScript implementation, the Godot modules,as well as the unofficial Python support for Godot.This would be a good starting point to see how another third-party libraryintegrates with Godot.

When is the next release of Godot out?¶

When it's ready! See When is the next release out? for moreinformation.

I would like to contribute! How can I get started?¶

Awesome! As an open-source project, Godot thrives off of the innovation andambition of developers like you.

The first place to get started is in the issues.Find an issue that resonates with you, then proceed to the How to Contributeguide to learn how to fork, modify, and submit a Pull Request (PR) with your changes.

Is it possible to use Godot to create non-game applications?¶

Yes! Godot features an extensive built-in UI system, and its small distributionsize can make it a suitable alternative to frameworks like Electron or Qt.

When creating a non-game application, make sure to enablelow-processor modein the Project Settings to decrease CPU and GPU usage.

That said, we wouldn't recommend using Godot to create a mobile applicationsince low-processor mode isn't supported on mobile platforms yet.

Check out Material Maker andPixelorama for examples ofopen source applications made with Godot.

Is it possible to use Godot as a library?¶

Godot is meant to be used with its editor. We recommend you give it a try, as itwill most likely save you time in the long term. There are no plans to makeGodot usable as a library, as it would make the rest of the engine moreconvoluted and difficult to use for casual users.

If you want to use a rendering library, look into using an established renderingengine instead. Keep in mind rendering engines usually have smaller communitiescompared to Godot. This will make it more difficult to find answers to yourquestions.

What user interface toolkit does Godot use?¶

Godot does not use a standard GUI toolkitlike GTK, Qt or wxWidgets. Instead, Godot uses its own user interface toolkit,rendered using OpenGL ES or Vulkan. This toolkit is exposed in the form ofControl nodes, which are used to render the editor (which is written in C++).These Control nodes can also be used in projects from any scripting languagesupported by Godot.

This custom toolkit makes it possible to benefit from hardware acceleration andhave a consistent appearance across all platforms. On top of that, it doesn'thave to deal with the LGPL licensing caveats that come with GTK or Qt. Lastly,this means Godot is "eating its own dog food" since the editor itself is one ofthe most complex users of Godot's UI system.

This custom UI toolkit can't be used as a library,but you can stilluse Godot to create non-game applications by using the editor.

Why does Godot not use STL (Standard Template Library)?¶

Like many other libraries (Qt as an example), Godot does not make use ofSTL. We believe STL is a great general purpose library, but we had specialrequirements for Godot.

• STL templates create very large symbols, which results in huge debug binaries. We use few templates with very short names instead.

• Most of our containers cater to special needs, like Vector, which uses copy on write and we use to pass data around, or the RID system, which requires O(1) access time for performance. Likewise, our hash map implementations are designed to integrate seamlessly with internal engine types.

• Our containers have memory tracking built-in, which helps better track memory usage.

• For large arrays, we use pooled memory, which can be mapped to either a preallocated buffer or virtual memory.

• We use our custom String type, as the one provided by STL is too basic and lacks proper internationalization support.

Why does Godot not use exceptions?¶

We believe games should not crash, no matter what. If an unexpectedsituation happens, Godot will print an error (which can be traced even toscript), but then it will try to recover as gracefully as possible and keepgoing.

Additionally, exceptions significantly increase binary size for theexecutable.

Why does Godot not enforce RTTI?¶

Godot provides its own type-casting system, which can optionally use RTTIinternally. Disabling RTTI in Godot means considerably smaller binary sizes canbe achieved, at a little performance cost.

Why does Godot not force users to implement DoD (Data oriented Design)?¶

While Godot internally for a lot of the heavy performance tasks attemptsto use cache coherency as well as possible, we believe most users don'treally need to be forced to use DoD practices.

DoD is mostly a cache coherency optimization that can only gain yousignificant performance improvements when dealing with dozens ofthousands of objects (which are processed every frame with littlemodification). As in, if you are moving a few hundred sprites or enemiesper frame, DoD won't help you, and you should consider a different approachto optimization.

The vast majority of games do not need this and Godot provides handy helpersto do the job for most cases when you do.

If a game that really needs to process such large amount of objects isneeded, our recommendation is to use C++ and GDNative for the highperformance parts and GDScript (or C#) for the rest of the game.

How can I support Godot development or contribute?¶

See Ways to contribute.

Who is working on Godot? How can I contact you?¶

See the corresponding page on the Godot website.