List of features

This page aims to list all features currently supported by Godot.

Note

This page lists features supported by the current stable version of Godot (4.0). Some of these features may not be available in the LTS release series (3.x).

Platforms

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.

  • Android 6.0 and later (editor support is experimental).

  • Web browsers. Experimental in 4.0, using Godot 3.x is recommended instead when targeting HTML5.

Runs exported projects:

Godot aims to be as platform-independent as possible and can be ported to new platforms with relative ease.

Editor

Features:

  • Scene tree editor.

  • Built-in script editor.

  • Support for external script editors such as Visual Studio Code or Vim.

  • GDScript debugger.

    • No support for debugging in threads yet.

  • Visual profiler with CPU and GPU time indications for each step of the rendering pipeline.

  • Performance monitoring tools, including custom performance monitors.

  • Live script reloading.

  • Live scene editing.

    • Changes will reflect in the editor and will be kept after closing the running project.

  • Remote inspector.

    • 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.

  • Built-in offline class reference documentation.

  • Use the editor in dozens of languages contributed by the community.

Plugins:

Rendering

3 rendering methods (running over 2 rendering drivers) are available:

  • Forward+, running over Vulkan 1.0 (with optional Vulkan 1.1 and 1.2 features). The most advanced graphics backend, suited for desktop platforms only. Used by default on desktop platforms.

  • Forward Mobile, running over Vulkan 1.0 (with optional Vulkan 1.1 and 1.2 features). Less features, but renders simple scenes faster. Suited for mobile and desktop platforms. Used by default on mobile platforms.

  • Compatibility, running over OpenGL 3.3 / OpenGL ES 3.0 / WebGL 2.0. The least advanced graphics backend, suited for low-end desktop and mobile platforms. Used by default on the web platform.

2D graphics

  • Sprite, polygon and line rendering.

    • High-level tools to draw lines and polygons such as Polygon2D and Line2D, with support for texturing.

  • AnimatedSprite2D as a helper for creating animated sprites.

  • Parallax layers.

    • Pseudo-3D support including preview in the editor.

  • 2D lighting with normal maps and specular maps.

    • Point (omni/spot) and directional 2D lights.

    • Hard or soft shadows (adjustable on a per-light basis).

    • Custom shaders can access a real-time SDF representation of the 2D scene based on LightOccluder2D nodes, which can be used for improved 2D lighting effects including 2D global illumination.

  • Font rendering using bitmaps, rasterization using FreeType or multi-channel signed distance fields (MSDF).

    • Bitmap fonts can be exported using tools like BMFont, or imported from images (for fixed-width fonts only).

    • Dynamic fonts support monochrome fonts as well as colored fonts (e.g. for emoji). Supported formats are TTF, OTF, WOFF1 and WOFF2.

    • Dynamic fonts support optional font outlines with adjustable width and color.

    • Dynamic fonts support variable fonts and OpenType features including ligatures.

    • Dynamic fonts support simulated bold and italic when the font file lacks those styles.

    • Dynamic fonts support oversampling to keep fonts sharp at higher resolutions.

    • Dynamic fonts support subpixel positioning to make fonts crisper at low sizes.

    • Dynamic fonts support LCD subpixel optimizations to make fonts even crisper at low sizes.

    • 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.

  • CPU-based particles.

2D tools

  • TileMaps for 2D tile-based level design.

  • 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.

2D physics

Physics bodies:

  • Static bodies.

  • Animatable bodies (for objects moving only by script or animation, such as doors and platforms).

  • Rigid bodies.

  • Character bodies.

  • Joints.

  • Areas to detect bodies entering or leaving it.

Collision detection:

  • Built-in shapes: line, box, circle, capsule, world boundary (infinite plane).

  • Collision polygons (can be drawn manually or generated from a sprite in the editor).

3D graphics

  • HDR rendering with sRGB.

  • Perspective, orthographic and frustum-offset cameras.

  • When using the Forward+ backend, a depth prepass is used to improve performance in complex scenes by reducing the cost of overdraw.

  • Variable rate shading on supported GPUs in Forward+ and Forward Mobile.

Physically-based rendering (built-in material features):

  • Follows the Disney PBR model.

  • Supports Burley, Lambert, Lambert Wrap (half-Lambert) and Toon diffuse shading modes.

  • Supports Schlick-GGX, Toon and Disabled specular shading modes.

  • Uses a roughness-metallic workflow with support for ORM textures.

  • Uses horizon specular occlusion (Filament model) to improve material appearance.

  • Normal mapping.

  • Parallax/relief mapping with automatic level of detail based on distance.

  • Detail mapping for the albedo and normal maps.

  • Sub-surface scattering and transmittance.

  • Screen-space refraction with support for material roughness (resulting in blurry refraction).

  • 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.

Real-time lighting:

  • Directional lights (sun/moon). Up to 4 per scene.

  • Omnidirectional lights.

  • Spot lights with adjustable cone angle and attenuation.

  • Specular energy can be adjusted on a per-light basis.

  • Adjustable light "size" for fake area lights (will also make shadows blurrier).

  • Optional distance fade system to fade distant lights and their shadows, improving performance.

  • When using the Forward+ backend (default on desktop), lights are rendered with clustered forward optimizations to decrease their individual cost. Clustered rendering also lifts any limits on the number of lights that can be used on a mesh.

  • When using the Forward Mobile backend, up to 8 omni lights and 8 spot lights can be displayed per mesh resource. Baked lighting can be used to overcome this limit if needed.

Shadow mapping:

  • 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 normal offset bias and 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 cast on.

  • Adjustable shadow 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 rough reflections based on spherical harmonics.

    • Lightmaps are baked on the GPU using compute shaders (much faster compared to CPU lightmapping). Baking can only be performed from the editor, not in exported projects.

  • Voxel-based GI probes. Supports dynamic lights and dynamic occluders, while also supporting reflections. Requires a fast baking step which can be performed in the editor or at run-time (including from an exported project).

  • Signed-distance field GI designed for large open worlds. Supports dynamic lights, but not dynamic occluders. Supports reflections. No baking required.

  • Screen-space indirect lighting (SSIL) at half or full resolution. Fully real-time and supports any kind of emissive light source (including decals).

  • VoxelGI and SDFGI use a deferred pass to allow for rendering GI at half resolution to improve performance (while still having functional MSAA support).

Reflections:

  • 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 box correction can optionally be enabled.

  • Screen-space reflections with support for material roughness.

  • Reflection techniques can be mixed together for greater accuracy or scalability.

  • When using the Forward+ backend (default on desktop), reflection probes are rendered with clustered forward optimizations to decrease their individual cost. Clustered rendering also lifts any limits on the number of reflection probes that can be used on a mesh.

  • When using the Forward Mobile backend, up to 8 reflection probes can be displayed per mesh resource.

De