List of features¶
This page aims to list all features currently supported by Godot.
This page lists features supported by the current development version of Godot (4.0.dev). Some of these features may not be available in the current stable release series (3.x).
Can run both the editor and exported projects:
Windows 7 and later (64-bit and 32-bit).
macOS 10.12 and later (64-bit, x86 and ARM).
Linux (64-bit, x86 and ARM).
Binaries are statically linked and can run on any distribution if compiled on an old enough base distribution.
Official binaries are compiled on Ubuntu 14.04.
32-bit binaries can be compiled from source.
Runs exported projects:
Android 4.4 and later.
iOS 10.0 and later.
HTML5 via WebAssembly (Firefox, Chrome, Edge, Opera).
Godot aims to be as platform-independent as possible and can be ported to new platforms with relative ease.
Scene tree editor.
Support for external script editors such as Visual Studio Code or Vim.
No support for debugging in threads yet.
Visual profiler with CPU and GPU time indications.
Performance monitoring tools.
Live script reloading.
Live scene editing.
Changes will reflect in the editor and will be kept after closing the running project.
Changes won't reflect in the editor and won't be kept after closing the running project.
Live camera replication.
Move the in-editor camera and see the result in the running project.
Use the editor in dozens of languages contributed by the community.
Editor plugins can be downloaded from the asset library to extend editor functionality.
Create your own plugins using GDScript to add new features or speed up your workflow.
Download projects from the asset library in the project manager and import them directly.
Sprite, polygon and line rendering.
High-level tools to draw lines and polygons such as Polygon2D and Line2D.
AnimatedSprite2D as a helper for creating animated sprites.
Pseudo-3D support by automatically duplicating a layer several times.
2D lighting with normal maps and specular maps.
Hard or soft shadows.
Font rendering using bitmaps, rasterization using FreeType or multi-channel signed distance fields (MSDF).
Bitmap fonts can be exported using tools like BMFont.
Dynamic fonts support monochrome fonts as well as colored fonts (e.g. for emoji). Supported formats are TTF, OTF and WOFF1.
Dynamic fonts support optional font outlines with adjustable width and color.
Dynamic fonts support variable fonts and OpenType features.
Dynamic fonts support oversampling to keep fonts sharp at higher resolutions.
Signed distance field fonts can be scaled at any resolution without requiring re-rasterization. Multi-channel usage makes SDF fonts scale down to lower sizes better compared to monochrome SDF fonts.
GPU-based particles with support for custom particle shaders.
2D camera with built-in smoothing and drag margins.
Path2D node to represent a path in 2D space.
Can be drawn in the editor or generated procedurally.
PathFollow2D node to make nodes follow a Path2D.
2D geometry helper class.
Line2D node to draw textured 2D lines.
Areas to detect bodies entering or leaving it.
Built-in shapes: line, box, circle, capsule.
Collision polygons (can be drawn manually or generated from a sprite in the editor).
HDR rendering with sRGB.
Perspective, orthographic and frustum-offset cameras.
Support for rendering 3D at a lower resolution while keeping 2D rendering at the original scale. This can be used to improve performance on low-end systems.
If you need OpenGL support, use Godot 3.x which remains supported.
Follows the Disney PBR model.
Uses a roughness-metallic workflow with support for ORM textures.
Parallax/relief mapping with automatic level of detail based on distance.
Sub-surface scattering and transmittance.
Proximity fade (soft particles) and distance fade.
Distance fade can use alpha blending or dithering to avoid going through the transparent pipeline.
Dithering can be determined on a per-pixel or per-object basis.
Directional lights (sun/moon). Up to 4 per scene.
Spot lights with adjustable cone angle and attenuation.
Adjustable light "size" for fake area lights (will also make shadows blurrier).
Lights are rendered with clustered forward optimizations to decrease their individual cost.
DirectionalLight: Orthogonal (fastest), PSSM 2-split and 4-split. Supports blending between splits.
OmniLight: Dual paraboloid (fast) or cubemap (slower but more accurate). Supports colored projector textures in the form of panoramas.
SpotLight: Single texture. Supports colored projector textures.
Shadow pancaking to decrease the amount of visible shadow acne and peter-panning.
PCSS-like shadow blur based on the light size and distance from the surface the shadow is casted on.
Adjustable blur on a per-light basis.
Global illumination with indirect lighting:
Baked lightmaps (fast, but can't be updated at run-time).
Supports baking indirect light only or baking both direct and indirect lighting. The bake mode can be adjusted on a per-light basis to allow for hybrid light baking setups.
Supports lighting dynamic objects using automatic and manually placed probes.
Optionally supports directional lighting and reflections based on spherical harmonics.
Lightmaps are baked on the GPU using compute shaders (much faster compared to CPU lightmapping).
GI probes (slower, fully real-time). Supports reflections.
Signed distance field GI (intermediate, supports dynamic lights but not dynamic occluders). Supports reflections.
Global illumination uses a deferred pass to allow for rendering GI at half resolution to improve performance.
Voxel-based reflections (when using GI probes) and SDF-based reflections (when using signed distance field GI).
Fast baked reflections or slow real-time reflections using ReflectionProbe. Parallax correction can optionally be enabled.
Reflection techniques can be mixed together for greater accuracy or scalability.
Panorama sky (using an HDRI).
Procedural sky and Physically-based sky that respond to the DirectionalLights in the scene.
Support for custom sky shaders, which can be animated.
Radiance can be updated in real-time depending on the quality settings chosen.
Exponential depth fog.
Exponential height fog.
Support for automatic fog color depending on the sky color (aerial perspective).
Support for sun scattering in the fog.
GPU-based particles with support for subemitters (2D + 3D), trails (2D + 3D), attractors (3D only) and collision (3D only).
Particle attractor shapes supported: box, sphere and 3D vector fields.
Particle collision shapes supported: box, sphere, baked signed distance field and real-time heightmap (suited for open world weather effects).
Trails can use the built-in ribbon trail and tube trail meshes, or custom meshes with skeletons.
Support for custom particle shaders with manual emission.
Tonemapping (Linear, Reinhard, Filmic, ACES).
Automatic exposure adjustments based on viewport brightness.
Near and far depth of field with adjustable bokeh simulation.
Screen-space ambient occlusion at half or full resolution.
Glow/bloom with optional bicubic upscaling and several blend modes available: Screen, Soft Light, Add, Replace, Mix.
Color correction using an one-dimensional ramp.
Roughness limiter to reduce the impact of specular aliasing.
Brightness, contrast and saturation adjustments.
Nearest, bilinear, trilinear or anisotropic filtering.
Filtering options are defined on a per-use basis, not a per-texture basis.
Basis Universal (slow, but results in smaller files).
BPTC for high-quality compression (not supported on macOS).
ETC2 (not supported on macOS).
S3TC (not supported on mobile/Web platforms).
Fast approximate antialiasing (FXAA).
Multi-sample antialiasing (MSAA).
Most of these effects can be adjusted for better performance or to further improve quality. This can be helpful when using Godot for offline rendering.
Built-in meshes: cube, cylinder/cone, (hemi)sphere, prism, plane, quad.
Tools for procedural geometry generation.
Constructive solid geometry (intended for prototyping).
Path3D node to represent a path in 3D space.
Can be drawn in the editor or generated procedurally.
PathFollow3D node to make nodes follow a Path3D.
3D geometry helper class.
Vehicle bodies (intended for arcade physics, not simulation).
Areas to detect bodies entering or leaving it.
Built-in shapes: cuboid, sphere, capsule, cylinder (only with Bullet physics).
Generate triangle collision shapes for any mesh from the editor.
Generate one or several convex collision shapes for any mesh from the editor.
2D: Custom vertex, fragment, and light shaders.
3D: Custom vertex, fragment, light, and sky shaders.
Text-based shaders using a shader language inspired by GLSL.
Visual shader editor.
Support for visual shader plugins.
Object-oriented design pattern with scripts extending nodes.
Signals and groups for communicating between scripts.
Support for cross-language scripting.
Many 2D and 3D linear algebra data types such as vectors and transforms.
Syntax inspired by Python. However, GDScript is not based on Python.
Syntax highlighting is provided on GitHub.
Use threads to perform asynchronous actions or make use of multiple processor cores.
Packaged in a separate binary to keep file sizes and dependencies down.
Uses Mono 6.x.
Full support for the C# 8.0 syntax and features.
Supports all platforms.
Using an external editor is recommended to benefit from IDE functionality.
Works best when used for specific purposes (such as level-specific logic) rather than as a language to create entire projects.
GDNative (C, C++, Rust, D, ...):
When you need it, link to native libraries for higher performance and third-party integrations.
For scripting game logic, GDScript or C# are recommended if their performance is suitable.
Official bindings for C and C++.
Use any build system and language features you wish.
Maintained D, Kotlin, Python, Nim, and Rust bindings provided by the community.
Mono, stereo, 5.1 and 7.1 output.
Non-positional and positional playback in 2D and 3D.
Optional Doppler effect in 2D and 3D.
Support for re-routable audio buses and effects with dozens of effects included.
Listener3D node to listen from a position different than the camera in 3D.
Audio input to record microphones.
No support for MIDI output yet.
Linux: PulseAudio or ALSA.
Support for custom import plugins.
Input mapping system using hardcoded input events or remappable input actions.
Axis values can be mapped to two different actions with a configurable deadzone.
Use the same code to support both keyboards and gamepads.
Keys can be mapped in "physical" mode to be independent of the keyboard layout.
The mouse cursor can be visible, hidden, captured or confined within the window.
When captured, raw input will be used on Windows and Linux to sidestep the OS' mouse acceleration settings.
Gamepad input (up to 8 simultaneous controllers).
Pen/tablet input with pressure support.
Low-level TCP networking using StreamPeer and TCP_Server.
Low-level UDP networking using PacketPeer and UDPServer.
Low-level HTTP requests using HTTPClient.
High-level HTTP requests using HTTPRequest.
Supports HTTPS out of the box using bundled certificates.
High-level multiplayer API using UDP and ENet.
Automatic replication using remote procedure calls (RPCs).
Supports unreliable, reliable and ordered transfers.
WebSocket client and server, available on all platforms.
WebRTC client and server, available on all platforms.
Support for UPnP to sidestep the requirement to forward ports when hosting a server behind a NAT.
Full support for Unicode including emoji.
Use localized strings in your project automatically in GUI elements or by using the
Support for bidirectional typesetting and text shaping and OpenType localized forms.
Automatic UI mirroring for right-to-left locales.
Windowing and OS integration¶
Move, resize, minimize, and maximize windows spawned by the project.
Change the window title and icon.
Request attention (will cause the title bar to blink on most platforms).
Doesn't use exclusive fullscreen, so the screen resolution can't be changed this way. Use a Viewport with a different resolution instead.
Borderless windows (fullscreen or non-fullscreen).
Ability to keep a window always on top.
Transparent windows with per-pixel transparency.
Global menu integration on macOS.
Execute commands in a blocking or non-blocking manner.
Open file paths and URLs using default or custom protocol handlers (if registered on the system).
Parse custom command line arguments.
In-app purchases on Android and iOS.
Support for advertisements using third-party modules.
XR support (AR and VR)¶
Support for ARKit on iOS out of the box.
Support for the OpenXR and OpenVR APIs.
Popular VR headsets like the Oculus Quest and HTC Vive are supported thanks to plugins.
Godot's GUI is built using the same Control nodes used to make games in Godot. The editor UI can easily be extended in many ways using add-ons.
Checkboxes, check buttons, radio buttons.
Text entry using LineEdit (single line) and TextEdit (multiple lines).
Dropdown menus using PopupMenu and OptionButton.
RichTextLabel for text formatted using BBCode.
Trees (can also be used to represent tables).
Containers (horizontal, vertical, grid, center, margin, draggable splitter, ...).
Controls can be rotated and scaled.
Anchors to keep GUI elements in a specific corner, edge or centered.
Containers to place GUI elements automatically following certain rules.
Scale to multiple resolutions using the
Support any aspect ratio using anchors and the
Built-in theme editor.
Generate a theme based on the current editor theme settings.
Procedural vector-based theming using StyleBoxFlat.
Supports rounded/beveled corners, drop shadows and per-border widths.
Texture-based theming using StyleBoxTexture.
Godot's small distribution size can make it a suitable alternative to frameworks like Electron or Qt.
Direct kinematics and inverse kinematics.
Support for animating any property with customizable interpolation.
Support for calling methods in animation tracks.
Support for playing sounds in animation tracks.
Support for Bézier curves in animation.
Scenes and resources can be saved in text-based or binary formats.
Text-based formats are human-readable and more friendly to version control.
Binary formats are faster to save/load for large scenes/resources.
Read and write text or binary files using File.
Can optionally be compressed or encrypted.
Read and write JSON files.
Read and write INI-style configuration files using ConfigFile.
Can (de)serialize any Godot datatype, including Vector, Color, ...
Read XML files using XMLParser.
Pack game data into a PCK file (custom format optimized for fast seeking), into a ZIP archive, or directly into the executable for single-file distribution.
Export additional PCK files that can be read by the engine to support mods and DLCs.
Low-level access to servers which allows bypassing the scene tree's overhead when needed.
Command line interface for automation.
Export and deploy projects using continuous integration platforms.
Completion scripts are available for Bash, zsh and fish.
Support for C++ modules statically linked into the engine binary.
Engine and editor written in C++17.
Can be compiled using GCC, Clang and MSVC. MinGW is also supported.
Friendly towards packagers. In most cases, system libraries can be used instead of the ones provided by Godot. The build system doesn't download anything. Builds can be fully reproducible.
Licensed under the permissive MIT license.
Open development process with contributions welcome.
The Godot proposals repository lists features that have been requested by the community and may be implemented in future Godot releases.