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

Godot isFree and open source Softwareavailable under theOSI-approved MIT license. This means it isfree 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 under the permissive Creative CommonsAttribution 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 theCOPYRIGHT.txtas well as theLICENSE.txtandLOGO_LICENSE.txt filesin the Godot repository.

Also, seethe license page on the Godot website.

Which platforms are supported by Godot?

For the editor:

• Windows

• macOS

• Linux, *BSD

• Android (experimental)

• Web (experimental)

For exporting your games:

• Windows

• macOS

• Linux, *BSD

• Android

• iOS

• Web

Both 32- and 64-bit binaries are supported where it makes sense, with 64being the default. Official macOS builds support Apple Silicon natively as well as x86_64.

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

The Godot team can't provide an open source console export due to the licensingterms imposed by console manufacturers. Regardless of the engine you use,though, releasing games on consoles is always a lot of work. You can read moreaboutConsole support in Godot.

For more on this, see the sections onexportingandcompiling Godot yourself.

Which programming languages are supported in Godot?

The officially supported languages for Godot are GDScript, 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 encountersome issues along the way. C# support is also currently missing on the webplatform. Our friendly and hard-working development community is alwaysready to tackle new problems as they arise, but since this is an open sourceproject, we recommend that you first do some due diligence yourself. Searchingthrough discussions onopen issuesis a great way to start your troubleshooting.

As for new languages, support is possible via third parties with GDExtensions. (See the questionabout plugins below). Work is currently underway, for example, on unofficial bindings for GodottoPython andNim.

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 and a complete overview of the power GDScript offersyou, check out theGDScript scripting guide.

There are several reasons to use GDScript, but the most salient reason is the overallreduction 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 forthree days. Just like Godot,once you see how powerful it is and how rapid your development becomes, we think GDScriptwill grow on you.

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

What were the motivations behind creating GDScript?

In the early days, the engine used theLua scriptinglanguage. Lua can be fast thanks to LuaJIT, but creating bindings to an object-orientedsystem (by using fallbacks) was complex and slow and took an enormousamount of code. After some experiments withPython,that 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 alarge amount of code, bugs, bottlenecks, and general inefficiency (Lua, Python,Squirrel, JavaScript, etc.). We wanted to focus on a great engine, not a great numberof integrations.

4. No native vector types (Vector3, Transform3D, 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 integrating with the code editor for providing codecompletion, live editing, etc. (all of them).

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

Which programming language is fastest?

In most games, thescripting language itself is not the cause of performanceproblems. Instead, performance is slowed by inefficient algorithms (which areslow in all languages), by GPU performance, or by the common C++ engine codelike physics or navigation. All languages supported by Godot are fast enough forgeneral-purpose scripting. You should choose a language based on other factors,like ease-of-use, familiarity, platform support, or language features.

In general, the performance of C# and GDScript is within the same order ofmagnitude, and C++ is faster than both.

Comparing GDScript performance to C# is tricky, since C# can be faster in somespecific cases. The C#language itself tends to be faster than GDScript, whichmeans that C# can be faster in situations with few calls to Godot engine code.However, C# can be slower than GDScript when making many Godot API calls, dueto the cost ofmarshalling. C#'s performance can also be brought down by garbagecollection which occurs at random and unpredictable moments. This can result instuttering issues in complex projects, and is not exclusive to Godot.

C++, usingGDExtension, will almost always befaster than either C# or GDScript. However, C++ is less easy to use than C# orGDScript, and is slower to develop with.

You can also use multiple languages within a single project, withcross-language scripting, or by usingGDExtension and scripting languages together. Be aware that doing so comes withits own complications.

What 3D model formats does Godot support?

You can find detailed information on supported formats, how to export them fromyour 3D modeling software, and how to import them for Godot in theImporting 3D scenes documentation.

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 can I extend Godot?

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

Also, see the official blog post on GDExtension, a way to develop native extensions for Godot:

• Introducing GDNative's successor, GDExtension

You can also take a look at the GDScript implementation, the Godot modules,as well as theJolt physics engine integrationfor Godot. This would be a good starting point to see how anotherthird-party library integrates with Godot.

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)orFlathub (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 issemi-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.SeeFile paths in Godot projects for more information.

Iftrue portable operation is desired (e.g. for use on a USB stick),follow the steps inSelf-contained mode.

Why does Godot prioritize Vulkan and OpenGL over Direct3D?

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

While Vulkan and OpenGL remain our primary focus for their open standard andcross-platform benefits, Godot 4.3 introduced experimental support for Direct3D 12.This addition aims to enhance performance and compatibility on platforms whereDirect3D 12 is prevalent, such as Windows and Xbox. However, Vulkan and OpenGLwill continue as the default rendering drivers 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 something not used often isadvanced artificial 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 responsibility 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 important 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.In terms of binary size, this also has the advantage of making you pay only forwhat you 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 single baseresolution for the game and only handle different screen aspect ratios. This ismostly needed for 2D, as in 3D, it's just a matter of camera vertical orhorizontal FOV.

1. Choose a single base resolution for your game. Even if there aredevices that go up to 1440p and devices that go down to 400p, regularhardware scaling in your device will take care of this at little orno performance cost. The 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; canvas items stretching while keepingaspect ratios works best. Check theMultiple 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 inMultiple resolutions.

4. For user interfaces, use theanchoringto 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.

When is the next release of Godot out?

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

Which Godot version should I use for a new project?

We recommend using Godot 4.x for new projects, but depending on the feature setyou need, it may be better to use 3.x instead. SeeWhich version should I use for a new project? for more information.

Should I upgrade my project to use new Godot versions?

Some new versions are safer to upgrade to than others. In general, whether youshould upgrade depends on your project's circumstances. SeeShould I upgrade my project to use new engine versions? for more information.

Should I use the Forward+, Mobile, or Compatibility renderer?

You can find a detailed comparison of the renderers inRenderers.

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

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

The best way to start contributing to Godot is by using it and reportinganyissues that you might experience.A good bug report with clear reproduction steps helps your fellow contributorsfix bugs quickly and efficiently. You can also report issues you find in theonline documentation.

If you feel ready to submit your first PR, pick any issue that resonates with you fromone of the links above and try your hand at fixing it. You will need to learn how tocompile the engine from sources, or how to build the documentation. You also need toget familiar with Git, a version control system that Godot developers use.

We explain how to work with the engine source, how to edit the documentation, andwhat other ways to contribute are there in ourdocumentation for contributors.

I have a great idea for Godot. How can I share it?

We are always looking for suggestions about how to improve the engine. User feedbackis the main driving force behind our decision-making process, and limitations thatyou might face while working on your project are a great data point for us when consideringengine enhancements.

If you experience a usability problem or are missing a feature in the current version ofGodot, start by discussing it with ourcommunity.There may be other, perhaps better, ways to achieve the desired result that community memberscould suggest. And you can learn if other users experience the same issue, and figure outa good solution together.

If you come up with a well-defined idea for the engine, feel free to open aproposal issue.Try to be specific and concrete while describing your problem and your proposedsolution — only actionable proposals can be considered. It is not required, butif you want to implement it yourself, that's always appreciated!

If you only have a general idea without specific details, you can open aproposal discussion.These can be anything you want, and allow for a free-form discussion in search ofa solution. Once you find one, a proposal issue can be opened.

Please, read thereadmedocument before creating a proposal to learn more about the process.

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.

Check outMaterial 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 standardGUI 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 toolkitcan't be used as a library,but you can stilluse Godot to create non-game applications by using the editor.

Why does Godot use the SCons build system?

Godot uses theSCons build system. There are noplans to switch to a different build system in the near future. There are manyreasons why we have chosen SCons over other alternatives. For example:

• Godot can be compiled for a dozen different platforms: all PCplatforms, all mobile platforms, many consoles, and WebAssembly.

• Developers often need to compile for several of the platformsatthe same time, or even different targets of the same platform. Theycan't afford reconfiguring and rebuilding the project each time.SCons can do this with no sweat, without breaking the builds.

• SCons willnever break a build no matter how many changes,configurations, additions, removals etc.

• Godot's build process is not simple. Several files are generated bycode (binders), others are parsed (shaders), and others need to offercustomization (modules). This requirescomplex logic which is easier to write in an actual programming language (like Python)rather than using a mostly macro-based language only meant for building.

• Godot's build process makes heavy use of cross-compiling tools. Eachplatform has a specific detection process, and all these must behandled as specific cases with special code written for each.

Please try to keep an open mind and get at least a little familiar with SCons ifyou are planning to build Godot yourself.

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

Like many other libraries (Qt as an example), Godot does not make use of STL(with a few exceptions such as threading primitives). We believe STL is a greatgeneral-purpose library, but we had special requirements for Godot.

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

• Most of our containers cater to special needs, like Vector, which uses copy on write and weuse 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 internalengine 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 bufferor virtual memory.

• We use our custom String type, as the one provided by STL is too basic and lacks properinternationalization 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 the binary size for theexecutable and result in increased compile times.

Does Godot use an ECS (Entity Component System)?

Godot doesnot use an ECS and relies on inheritance instead. While thereis no universally better approach, we found that using an inheritance-based approachresulted in better usability while still being fast enough for most use cases.

That said, nothing prevents you from making use of composition in your projectby creating child Nodes with individual scripts. These nodes can then be added andremoved at runtime to dynamically add and remove behaviors.

More information about Godot's design choices can be found inthis article.

Why does Godot not force users to implement DOD (Data-Oriented Design)?

While Godot internally attempts to use cache coherency as much as possible,we believe users don't need to be forced to use DOD practices.

DOD is mostly a cache coherency optimization that can only providesignificant performance improvements when dealing with dozens ofthousands of objects which are processed every frame with littlemodification. That is, if you are moving a few hundred sprites or enemiesper frame, DOD won't result in a meaningful improvement in performance. Insuch a case, you should consider a different approach to 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 needs to process such a large amount of objects, our recommendationis to use C++ and GDExtensions for performance-heavy tasks and GDScript (or C#)for the rest of the game.

How can I support Godot development or contribute?

SeeHow to contribute.

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

See the corresponding page on theGodot website.