godotengine/godot-demo-projects

Features

• Game Implementation Samples - Provides a comprehensive collection of functional 2D and 3D demo projects as implementation samples.
• Node-Based - Uses a hierarchical scene graph of nodes as the primary architectural pattern for game construction.
• Multi-Platform Export Tools - Provides a comprehensive suite of tools to compile and package projects for Windows, macOS, Linux, Android, iOS, and Web.
• Game Editors - Provides visual tools for designing and arranging assets within 2D and 3D game worlds.
• 2D Level Creation - Implements 2D level construction using TileMaps for grid design and Path2D for trajectories.
• Integrated Development Tooling - Integrates scripting, animation, tilemap, and shader editors into a single unified workspace.
• Cross-Platform Build Targets - Packages project data into platform-specific binaries for desktop, mobile, and web environments using export presets.
• File and Resource Management - Provides tools for creating, saving, and loading game resources from the filesystem and clipboard.
• Integrated Development Suites - Provides a comprehensive suite including a scene tree editor, script editor, debugger, and performance profilers.
• Inspector Variable Exposure - Allows developers to expose script variables for direct adjustment within the editor's inspector panel.
• Project Configuration - Offers centralized project configuration for defining global physics, rendering, and windowing parameters.
• Game Object Compositions - Demonstrates the composition of game objects using modular units that bundle logic and structure.
• Game Development Tutorials - Provides interactive demo projects designed to teach game engine fundamentals through hands-on exploration.
• Game Development - Serves as a comprehensive reference library for implementing game mechanics and rendering systems.
• 2D Physics Simulations - Provides a complete 2D physics simulation including static, rigid, and character bodies with collision detection.
• 2D User Interface Construction - Provides a dedicated node-based system for constructing 2D graphical user interfaces.
• 3D Performance Optimization - Optimizes 3D frame rates using mesh level-of-detail, occlusion culling, and resolution scaling.
• 3D Scene Editors - Provides specialized 2D and 3D viewports for arranging nodes and objects within a scene.
• 3D World Building - Offers comprehensive tools for building 3D worlds with PBR, global illumination, and volumetric fog.
• Component Property Editing - Implements a property inspector for modifying the attributes and configurations of scene elements.
• Scene Graphs - Utilizes scene graphs to organize visual and logic components into hierarchical trees for modularity.
• Reusable Scene Templates - Godot groups nodes into instantiable and inheritable units that define structure and signal connections.
• Game Asset Importers - Processes external images, audio, translations, and 3D scenes into a compatible internal format.
• 2D Game Frameworks - Provides a dedicated workflow for creating 2D games with tile-based levels and sprite animations.
• Cross-Platform - Supports exporting and deploying projects across Windows, macOS, Linux, Android, iOS, and Web.
• Game Logic Scripting - Implements custom interactive behaviors and game logic using a dedicated scripting language.
• Implementation Guides - Offers practical examples for using the node system, scripting, and asset pipelines.
• 2D Level Design - Provides comprehensive examples of building game worlds using a tile-based system.
• Multiplayer Networking - Provides high-level RPC-based replication and low-level TCP, UDP, HTTP, and WebSocket communication.
• Object Templates - Godot defines a collection of nodes and properties as a saved scene for reproduction across a project.
• Prefab Instantiation - Implements the deployment of multiple copies of template-based objects into a live game world.
• Prefabricated Game Objects - Provides implementation samples for creating and instantiating prefabricated game objects from saved scene files.
• Scene Hierarchy Structuring - Organizes project code and scene hierarchies using a node-based, object-oriented design approach.
• Tile Map Authoring Tools - Provides a practical guide to constructing game worlds by painting tiles onto a grid.
• Asset Pipelines - Provides a comprehensive system for managing the loading, processing, and caching of game assets.
• Custom Shader Programming - Provides a GLSL-inspired language and visual editor for authoring custom vertex, fragment, and light shaders.
• Physically Based Rendering - Simulates realistic surfaces using physically based rendering materials with albedo, roughness, and normal maps.
• Input Event Processing - Translates raw hardware interactions into discrete software events to trigger in-game actions.
• Event-Driven Signal Systems - Implements a signal-based system to facilitate decoupled communication between objects via runtime emitter-receiver connections.
• Custom Signal Definitions - Enables the creation of custom, application-specific events that can carry optional data arguments.
• Node Lifecycle Management - Provides hooks to execute logic when nodes enter the scene tree or change their hierarchical relationships.
• Game Loop Updates - Godot executes code every frame using framerate-dependent or independent timing for physics updates.
• Node-Based Composition - Implements a node-based composition system for building complex game entities through hierarchical nesting.
• Component Communication - Uses a signal system to allow decoupled components to communicate without direct code dependencies.
• Custom Event Systems - Implements a framework for defining and emitting custom events to notify system components of game state changes.
• Game Input Mapping - Interfaces with gamepads and joysticks to translate analog and digital hardware signals into game commands.
• Game Overlays and HUDs - Implements specialized graphical interfaces for heads-up displays and non-diegetic menu overlays.
• Input Control Mappings - Unifies keyboard and controller inputs into named abstract actions to streamline input logic.
• Input Handling - Processes user input devices to trigger specific logic in response to discrete events like button presses.
• Visual Property Editors - Implements a visual interface with sliders and dropdowns to modify object attributes.
• UI Layout Design - Utilizes anchor presets to position and size interactive elements relative to screen edges.
• User Interface Construction - Implements GUI creation through a system of control nodes and a vector-based theme editor.
• User Interface Design - Creates on-screen displays using labels and containers with customizable themes, fonts, and colors.
• Event-Driven Messaging Systems - Implements an event-driven architecture allowing objects to react to messages without direct references.
• Character Controllers - Manages player movement and physics interactions for characters in 2D environments.
• Gamepad Haptics - Activates gamepad vibration and mobile haptics to provide tactile feedback to the player.
• Inverse Kinematics - Provides inverse kinematics to automatically adjust parent bones based on a limb's extremity position.
• Tile Physics and Navigation - Provides samples for adding collision polygons and navigation meshes to tiles for object interaction.
• Lighting and Shadows - Implements 2D shadow casting using occluder polygons to block light sources.
• Live Preview - Provides a live preview mode to test game mechanics and adjust parameters during execution.
• Collision Filtering - Implements layers and masks to define specific interaction groups and collision rules.
• Touch and Mouse Events - Captures and processes mouse and touch pointer data to track user interaction.
• File-Based Storage Systems - Implements persistence of application settings and game data using JSON and INI files.
• User Data Storage - Saves player data and application settings to platform-specific writable directories.
• Resource Archive Exports - Generates standalone PCK or ZIP archives containing resources specifically for modding and patching.
• File Storage Management - Manages the lifecycle of files being loaded and saved to the local system during execution.
• Game State Persistence - Provides functionality to save and restore game states by reinstantiating objects from disk.
• 3D Scene Exporters - Translates internal 3D scene representations into glTF 2.0 files for use in external modeling software.
• 3D Scene Importers - Converts 3D files from various formats into engine-compatible scenes with customizable node types.
• Object - Serializes object data into JSON strings or binary formats for later retrieval and restoration.
• Build Optimization - Optimizes the final executable size through a combination of compilation settings and asset optimization.
• Build & Release Automation - Godot triggers release or debug builds from the command line for CI/CD pipelines.
• Code Editors - Includes a built-in code editor with auto-completion and debugging tools for game logic development.
• Editor-Integrated Debugging - Supports step-through debugging in external editors via the Debug Adapter Protocol.
• Editor Extensions - Allows the creation of custom plugins and tools by running game code within the editor.
• Frame-by-Frame Debuggers - Provides the ability to pause execution and advance the game frame-by-frame to diagnose timing issues.
• Headless Engine Control - Godot executes engine functions and project tasks using terminal commands to automate workflows.
• Input Mapping Engines - Implements a system to map multiple physical inputs to abstract named actions for flexible remapping.
• Integrated Asset Editors - Integrates specialized editors for code, animations, tilemaps, and shaders into the development workspace.
• Integrated Script Editors - Includes a built-in text editor with syntax highlighting and code folding for project scripts.
• Browser-Based Development Environments - Provides a fully functional integrated editor and project creation environment within a web browser.
• Scene-Based Modularity - Shows how to build modular game elements, such as characters or weapons, as reusable scenes.
• Headless Build Generation - Godot generates release or debug builds without a graphical window for CI pipelines.
• iOS Project Generation - Generates complete Xcode projects with unique bundle identifiers for deployment on iOS devices.
• Linux Binary Packaging - Bundles project files into compressed packages with optimized headless binaries for Linux.
• Project Imports - Supports loading existing projects from local folders, specific project files, or ZIP archives into the editor.
• 3D Model Importers - Integrates 3D assets from external software by parsing geometry and material data from formats like glTF and Blend.
• Project Initializers - Provides tools to bootstrap new projects by defining names, storage locations, and rendering backends.
• Project Templates - Enables browsing and installing open-source demo projects and boilerplate templates from a remote library.
• Runtime Hardware Configuration - Godot manages application lifecycle and configures hardware drivers using command line arguments.
• Cross-Platform Execution - Supports native operation of the development editor on Android, VR headsets, and web browsers.
• Project Management - Provides a centralized manager for creating, importing, and organizing multi-file project resources and configurations.
• Universal Binary Packaging - Creates universal binary app bundles compatible with both Intel and Apple Silicon macOS architectures.
• Deployment Targets - Supports exporting and installing projects across various hardware architectures and operating systems.
• Distribution and Packaging - Bundles projects into standalone executables compatible with desktop, mobile, and web platforms.
• Game Build Packaging - Godot bundles project data and executables into playable builds using export presets.
• Android Packages - Implements tools for generating APK and AAB files for distribution on Android devices.
• Headless Execution Modes - Provides a headless execution mode for running the engine on servers without a GPU or display.
• Programming Courses - Offers an interactive browser-based course to teach scripting basics and programming fundamentals to beginners.
• Technical Documentation - Includes a built-in technical API reference for classes, methods, and signals directly within the editor.
• 3D Physics Engines - Implements a 3D physics environment for calculating real-time rigid body dynamics and collisions.
• Runtime Scene Inspection - Allows selecting and modifying nodes in a running game instance to evaluate property changes instantly.
• Asynchronous Asset Loading - Implements background loading of game resources to prevent runtime stuttering and freezing.
• Coordinate-Based Movement - Implements character navigation to spatial coordinates in 3D space using kinematic bodies.
• Custom Component Type Registrations - Godot registers scripts as named types in the editor creation dialog with specific icons.
• Dedicated Server Build Profiles - Creates optimized server-side binaries by stripping unnecessary visual resources from the project.
• Delta-Time Transformations - Updates object position and rotation over time using delta time to ensure consistent motion regardless of frame rate.
• Scene Inheritance - Provides examples of scene property inheritance to extend functionality while maintaining links to base scenes.
• External DCC Integrations - Integrates directly with an external Blender installation to automatically import .blend files.
• 3D Asset Configuration - Provides tools for adjusting rendering parameters, physics properties, and attachment points for imported 3D models.
• Code-Based Scene Instantiation - Enables the creation of complex object hierarchies and scene contents entirely through code.
• Object Spawning - Demonstrates the runtime creation of game objects at random locations to simulate enemy behavior.
• Gameplay Timing Systems - Godot uses timer nodes to trigger recurring events, create gameplay delays, or track time-based scoring.
• Group-Based Object Tagging - Assigns custom labels to nodes to differentiate object types during collision detection.
• Integrated Editor Play-Windows - Provides a floating window within the editor to run and inspect the game in real-time.
• Level Construction - Constructs game environments using grid-based maps, CSG prototyping tools, and specialized cameras.
• Level Design Tools - Provides tools for designing 2D and 3D levels using GridMaps and procedural geometry generation.
• Native Executable Generation - Produces standalone Windows executables optimized for x8664, x8632, and arm64 architectures.
• Navigation Mesh Generation - Creates walkable regions for AI agents by baking navigation meshes onto items within a mesh library.
• On-Device XR Development - Enables the development environment to run natively on XR hardware for on-device game creation.
• Mobile Service Integrations - Integrates native mobile features including virtual touch controls, in-app purchases, and advertisement modules.
• Pathfinding Integration - Implements A* algorithms and navigation meshes for dynamic obstacle avoidance in 2D and 3D environments.
• Jump Mechanics - Applies vertical impulses to physics bodies when jumping input is triggered while touching the floor.
• Collision Detection - Provides systems for defining and calculating intersections using static physical boundaries.
• Overlap Detection - Uses area-based sensors to detect when two or more objects overlap in a 2D environment.
• Collision Layer Management - Utilizes physics layers and groups to identify and respond to collisions between specific object types.
• Project Hierarchy Organization - Provides examples of organizing game projects into structured hierarchies with main entry points and subsystems.
• Random Number Generation - Produces pseudo-random values to drive gameplay mechanics and procedural generation.
• State-Driven Movement Execution - Translates user input into directional vectors to execute physical movements for 3D characters.
• Tile Metadata Layers - Godot attaches game-specific data layers to tiles to store properties like damage values per tile.
• Tileset Management Systems - Demonstrates generating a grid of tiles from a tilesheet with custom margins and padding.
• Unified Input Handling - Processes hardware signals from keyboards, controllers, and touchscreens to trigger game logic.
• XR Hardware Integrations - Integrates with OpenXR to provide broad support for VR and AR headsets across platforms.
• 2D Lighting Simulation - Implements 2D light sources using textures and blend modes for atmospheric effects.
• 2D Scene Illumination - Provides examples of using dynamic lighting and custom shaders to illuminate 2D scenes.
• 2D Spatial Audio - Enables 2D audio positioning where volume and panning shift dynamically based on player location.
• 2D Sprite Animations - Provides implementation samples for frame-based 2D sprite animations for characters and objects.
• Sprite Sheet Slicing - Sequences individual images or slices sprite sheets to create looping visual animations.
• 3D Asset Exporters - Facilitates the transfer of 3D models and scenes from Blender into engine-compatible formats.
• 3D Lighting and Shadows - Adds directional and positional light sources to illuminate 3D surfaces and create realistic shadows.
• Animation Graph Authoring - Implements animation graph authoring to mix multiple sequences using blend spaces and transition nodes for smooth motion.
• Audio Bus Routing - Features a robust audio bus system for routing sounds and applying real-time effects to grouped signals.
• Audio Playback - Manages positional 2D and 3D audio, re-routable mixer buses, and real-time pitch scaling.
• On-Demand Audio Triggers - Implements event-driven audio triggers to play sound effects and music for gameplay feedback.
• Effects Processing - Includes a suite of audio effects like reverb, delay, and chorus to simulate environmental acoustics.
• Signal Routing - Manages the flow of audio signals between sources, effects buses, and the final output device.
• Spatial Audio - Provides 3D spatial audio that adjusts stereo and surround sound output based on the listener's location.
• Bézier Curve Interpolations - Interpolates property values using adjustable cubic Bézier curves for organic and precise motion.
• Camera Systems - Implements virtual camera systems with spring arms and smoothing for third-person perspectives.
• Camera Perspective Configurations - Controls scene perspective and projection through active cameras associated with viewports.
• Particle Effect Simulations - Generates complex atmospheric effects using a dedicated 2D particle simulation system.
• Runtime Animation Scaling - Creates movement animations and adjusts playback speed at runtime to match character velocity.
• Animation Asset Importing - Extracts animation data from 3D files to create shared libraries applicable to multiple characters.
• Cutout Animation - Animates 2D characters by manipulating separate body parts as a rig, blending motion with cel animation.
• Dynamic Reflection Probes - Implements dynamic 3D reflections using probes and voxel-based techniques that update in real-time.
• Screen Space Reflection Techniques - Produces real-time reflections of opaque geometry using screen-space techniques for objects in close contact with surfaces.
• Procedural Mesh Generation - Creates custom static or dynamic meshes programmatically using vertex arrays and immediate-mode APIs.
• Vertex Attribute Definition - Provides examples of building 3D meshes by programmatically defining vertex attributes, normals, and UV maps.
• Mesh Deformations - Allows real-time deformation of objects by converting mesh data into editable arrays at runtime.
• Mesh Optimization - Generates and swaps simplified 3D mesh versions based on screen-space metrics to optimize rendering.
• 3D Lighting Models - Simulates light emission through directional, omnidirectional, spot, and area sources to control intensity.
• Advanced Lighting Effects - Simulates complex light behaviors including subsurface scattering, refraction, and rim lighting.
• Area Light Sources - Simulates soft, diffuse light from a rectangular surface, supporting custom textures and energy normalization.
• Screen Space Ambient Occlusion - Implements screen-space ambient occlusion to add depth by darkening concave areas and crevices in 3D scenes.
• SDF Global Illumination - Implements real-time global illumination for on-screen and off-screen elements using signed distance fields.
• Post-Processing Effects - Applies full-screen visual filters and custom shaders to the final rendered image via viewports.
• Atmospheric Fog - Fades distant objects into a uniform color using distance-based or height-based fog simulations.
• Physical Camera Models - Controls field of view, focus distance, and depth of field using real-world lens properties.
• Procedural Mesh Generators - Implements interfaces for constructing 3D geometry and meshes programmatically at runtime using surface tools.
• High Dynamic Range Rendering - Maps high dynamic range colors to a displayable range using industry-standard tonemapping algorithms.
• 3D Scene Renderers - Produces 3D visual scenes using physically-based materials, lighting, and global illumination.
• Volumetric Rendering Engines - Implements volumetric fog and defined fog volumes to add atmospheric depth and light scattering.
• Environment Configuration - Defines background colors, skyboxes, and post-processing effects to establish a global visual atmosphere.
• Recursive Scene Nesting - Demonstrates scene nesting where changes to a base scene are automatically propagated to all its instances.
• Material-to-Shader Conversions - Allows the conversion of standard process materials into custom shaders for unique rendering behaviors.
• 2D Rendering Engines - Features a dedicated 2D renderer supporting sprites, polygons, and hardware-accelerated parallax layers.
• Mesh-Based 2D Optimization - Improves performance by converting images with transparent areas into efficient 2D meshes.
• Hierarchical Level of Detail - Implements hierarchical LOD by replacing detailed object groups with simplified meshes at a distance to reduce draw calls.
• Hybrid 2D/3D Rendering - Uses dedicated 2D and 3D engines to allow 2D elements to be overlaid within 3D coordinate systems.
• Indirect Lighting Simulation - Applies global illumination to all geometry using colors, sky data, or probe-based sources.
• Light Probes - Uses light probes to capture and apply baked indirect lighting to moving 3D objects.
• Lightmap Baking - Calculates and stores bounced light into textures to provide high-quality global illumination with minimal runtime cost.
• Screen-Space Indirect Lighting - Adds secondary indirect lighting and emissive detail based on the visible pixels of the current frame.
• Animation Pipelines - Implements animation pipelines for authoring and blending character movements using skeletal rigs and IK.
• Keyframe Animations - Implements animation systems that generate motion by calculating intermediate states between defined keyframes.
• Timeline Authoring - Features a visual timeline for creating and interpolating keyframes for node properties.
• State-Based Animation Systems - Controls the flow between animations using a state machine with immediate or synchronized transitions.
• Mesh Instancing - Populates surfaces with numerous copies of a single mesh using randomized scales and orientations via multi-mesh instancing.
• 2D Mesh Deformations - Demonstrates how to apply organic stretching and wobbling effects to 2D character rigs.
• 2D Skeletal Rigs - Rigs 2D characters with skeletal hierarchies and bones to enable fluid movement via inverse kinematics.
• Animation Retargeting - Provides tools to map bone names and rest poses between different skeletal models to share animations across characters.
• Skeletal Hierarchies - Connects nodes into a skeletal hierarchy to enable articulated movement and complex rigging.
• Skeletal Rigging - Defines bone hierarchies and rest poses to establish a structural framework for character deformation.
• Micro-Detail Surface Simulation - Emulates fine geometric surface detail using normal maps, height maps, and ambient occlusion.
• PBR Material Authoring - Defines surface properties such as color and roughness using a standard physical rendering model.
• Physically Based Lighting - Uses real-world light units and conversion calculations to achieve physically accurate illumination.
• Physics Debug Rendering - Provides tools for drawing simple shapes and lines to visualize physics and prototyping data.
• Real-Time 3D Rendering Engines - Implements a real-time 3D rendering engine with physically-based rendering and shadow mapping.
• Procedural Mesh Generation - Enables the programmatic creation and real-time update of 3D meshes every frame.
• Reflection Probes - Captures reflected and ambient light for objects within specific areas to create accurate visual reflections.
• Root Motion Synchronization - Synchronizes a character's world position by extracting transformation data from a designated skeleton bone.
• Scene Geometry Instancing - Generates visible 3D geometry by assigning mesh resources to instances within a scene.
• Distance-Based LOD Management - Controls object visibility and model complexity based on distance to optimize rendering.
• Skybox and Background Generation - Generates 3D backgrounds using panoramas, scattering, and procedural parameters to create realistic skies.
• Voxel-Based Global Illumination - Demonstrates real-time indirect lighting calculations for 3D scenes using a voxel-based approach.
• VR Experience Creation - Provides tools and examples for building VR and AR experiences with body tracking and passthrough.
• World Streaming - Provides real-time loading and unloading of scene segments to balance memory usage and performance in large environments.
• Analog Input Calibration - Captures variable strength values from joysticks and triggers with circular deadzone processing.
• Kinematic Body Locomotion - Implements 3D kinematic movement including velocity calculations and sliding against physical obstacles.
• Android Development - Enables the creation and export of game projects directly on Android devices.
• Filesystem APIs - Provides a flexible file access API for reading and writing plain text or custom binary data.
• Reference Counting - Uses reference counting to automatically deallocate memory when no active references to an object remain.
• Resource Loading - Implements strategic loading of assets, choosing between immediate and on-demand loading to prevent runtime stutters.
• Binary Size Optimizations - Reduces the disk footprint of compiled binaries by disabling unused engine features and classes.
• Runtime Signal Binding - Allows establishing event connections at runtime for dynamically instantiated objects or scenes.
• Scripting and Compiled Language Integration - Supports implementing gameplay logic using a choice of high-level scripting or high-performance compiled languages.
• C++ Engine Extensions - Implements performance-critical code in C++ via a bridge API for maximum execution speed.
• Multi-threaded Execution - Implements multi-threaded execution to distribute tasks across CPU cores for improved responsiveness.
• .NET Ecosystem Integrations - Godot incorporates third-party .NET frameworks and libraries to extend functionality.
• Engine Class Extensions - Godot creates custom types by attaching scripts to base engine classes to add new properties.
• Visual Signal Connection - Provides a visual interface for linking event emitters to receiver functions without writing code.
• Template Instance Overriding - Implements object instance management allowing individual property overrides for template-based game objects.
• Singleton Patterns - Implements global singleton patterns via autoload nodes for persistent, project-wide state access.
• Logic-Rendering Decouplers - Implements patterns that separate behavioral scripts from visual scene configurations to improve version control.
• Native Plugin Development - Provides toolkits for developing native plugins that interface directly with the engine core on iOS and Android.
• Asset Packages - Bundles game assets into optimized PCK or ZIP archives for efficient distribution and modding.
• Rendering Optimizations - Optimizes 3D rendering performance using mesh level-of-detail (LOD), occlusion culling, and visibility ranges.
• Scene Communication Decoupling - Implements scene dependency decoupling using signals to facilitate communication between isolated sub-scenes.
• Shared Resource Objects - Uses dedicated resource objects to distribute and share common data across different game scenes.
• Global State Managers - Provides centralized state management using autoloads to maintain data persistence across scene transitions.
• Internal Resolution Scaling - Adjusts internal 3D rendering resolution independently of the window size to balance quality and performance.
• Animation Easing Functions - Applies easing curves to keyframes to control acceleration and deceleration for refined motion feel.
• Tree-Based Blending Logic - Godot coordinates complex animation state transitions and blending logic using a tree structure.
• Animation Properties - Interpolates any node property, script variable, or function call over time via animation tracks.
• Character Ragdolls - Simulates articulated character bodies to create realistic collapse and impact behaviors.
• Canvas Layer Management - Provides samples for organizing 2D elements into layers to control rendering order and scale.
• Transform Animations - Controls the location, rotation, and scale of 3D objects using optimized compressed animation tracks.
• Heads-Up Displays - Godot renders a persistent informational overlay using a dedicated layer to prevent obstruction.
• Rendering Throughput Optimizers - Optimizes rendering throughput by using MultiMesh to render thousands of similar objects in a single draw call.
• Animation Sequence Managers - Blends multiple sequences and manages hierarchical transitions using animation sequence managers.
• Animation Sequencing - Coordinates the timing and order of multiple concurrent animations to choreograph complex scenes.
• Triplanar Texture Sampling - Samples textures along three axes to ensure seamless blending across 3D surfaces without requiring UV maps.
• Triplanar Mapping - Maps textures to 3D surfaces without distortion by projecting from three axes.
• Viewport Coordinate Mapping - Retrieves pointer positions using both hardware display and scaled viewport coordinates.
• External Resource Loading - Fetches scenes, scripts, and data files from disk using static preloading or dynamic runtime loading.
• Game Server Hosting - Produces optimized builds for game server environments by disabling GPU and audio drivers.
• WebAssembly Exports - Exports projects to a WebAssembly and WebGL 2.0 compatible format for seamless web deployment.
• Engine Demos - Official engine demonstration projects.

Star history