This demo contains a series of tests for the 3D physics engine. They can be used for different purposes: - Functional tests to check for regressions and compare the behavior between physics engines - Performance tests to evaluate and compare performance between physics engines Language: GDScript Renderer: Forward+

This demo showcases a physical light and camera units setup: https://docs.godotengine.org/en/latest/tutorials/3d/physical_light_and_camera_units.html This allows you to use real world units for lights (lumen, lux, Kelvin) and cameras (shutter speed, aperture, ISO sensitivity). By default, Godot uses arbitrary units for many physical properties that apply to light like color, energy, camera field of view, and exposure. These properties use arbitrary units, because using accurate physical units comes with a few tradeoffs that aren't worth it for many games. As Godot favors ease of use out of the box, physical light units are disabled by default. If you aim for photorealism in your project, using real world units as a basis can help make things easier to adjust. References for real world materials, lights and scene brightness are wildly available on websites such as Physically Based: https://physicallybased.info/ Language: GDScript Renderer: Forward+

This project showcases various 3D particle features supported by Godot, for both GPU-based and CPU-based particles. This includes particle collision, attractors, trails and subemitters. Language: GDScript Renderer: Forward+

A demo of how to sync the audio playback with the time for a consistent BPM (beats per minute). How it works: For the sound clock, it uses methods in the AudioServer singleton to synchronize the audio playback. For the system clock, it uses `Time.get_ticks_usec()`. Language: GDScript Renderer: Compatibility

This is an example of displaying GUI elements such as Labels in a 3D world, by projecting the 3D position onto the screen and displaying the GUI elements directly, instead of relying on viewports. This results in better readability and performance for use cases such as showing player names. Some waypoints showcased in the demo will also snap to the window borders when outside the player's view. No Viewport or Sprite3D nodes are used in this demo. Language: GDScript Renderer: Forward+

This demo includes many sphere-like objects with complex materials, for the purpose of showcasing Godot's rendering capabilities. This demo was featured at the beginning of the Godot 3.0 trailer: https://www.youtube.com/watch?v=XptlVErsL-o Language: GDScript Renderer: Forward+

This project showcases various 3D light and shadow features supported by Godot. This includes contact-hardening shadows (PCSS) and light projectors. The background sky uses a PhysicalSkyMaterial, which allows for the sky colors to be automatically adjusted as the sun performs a day/night cycle. The radiance map (used to provide ambient and reflected light to the scene) is updated in real-time with the environment sky's process mode set accordingly. Language: GDScript Renderer: Forward+

A demo showing advanced tween usage. Language: GDScript Renderer: Compatibility

This is a sample consisting of different shaders applied to some sprites. Effects include outlines, blurs, distorts, shadows, glows, and more. Language: Godot shader language Renderer: Compatibility

This demo shows how to create a rigged and animated character in 2D using Godot's Skeleton2D node. There are several movement-related animations and there is a simple character controller that controls the animations. Language: GDScript Renderer: Compatibility

Several examples of full screen 2D shader processing. Many common full-res effects are implemented here for reference. Language: Godot shader language and GDScript Renderer: Compatibility

This shows a method of creating grid-based movement with Godot and GDScript. It also includes a simple JRPG-style dialogue and battle system on top of it. Language: GDScript Renderer: Compatibility

Visual demonstration of FastNoiseLite library in Godot 4 for procedural generation of 2d tilemaps. Project has been upgraded to 4.2

This is a sample project which allows the user to tweak different parameters of a FastNoiseLite texture. Language: GDScript Renderer: Compatibility

An example using a thread to load an image. See documentation on using multiple threads: https://docs.godotengine.org/en/stable/tutorials/performance/using_multiple_threads.html Language: GDScript Renderer: Mobile

A demo showing regex functionality and usage. Can also serve as a playground for regex testing. Language: GDScript Renderer: Compatibility

A demo showcasing the Pseudolocalization feature in Godot: https://docs.godotengine.org/en/stable/tutorials/i18n/pseudolocalization.html Language: GDScript Renderer: Compatibility

This demo showcases how to save a simple game with each serialization format supported by Godot: - ConfigFile - JSON More formats may be added in the future. For more information, see Saving games in the documentation: https://docs.godotengine.org/en/latest/tutorials/io/saving_games.html See the "Run-time File Saving and Loading" demo for an example of loading various file types in an exported project without needing to import them. Language: GDScript Renderer: Compatibility

This sample project showcases an implementation of dynamic split screen, also called Voronoi split screen. Details: A dynamic split screen system displays a single screen when the two players are close but a splitted view when they move apart. The splitting line can take any angle depending on the players' position, so it won't be either vertical or horizontal. This system was popularized by the LEGO videogames. How it works: Two cameras are placed inside two separate viewports and their texture, as well as some other parameters, are passed to a shader attached to a TextureRect filling the whole screen. The `SplitScreen` shader, with the help of the `CameraController` script, chooses wich texture to display on each pixel to achieve the effect. The cameras are placed on the segment joining the two players, either in the middle if they're close enough or at a fixed distance otherwise. How to use it: Open and launch the project inside the Godot engine, then use WASD to move the first player (in red) and IJKL (or arrow keys) to move the second player (in blue). The `camera_controller.gd` script sets parameters to tune the distance at which the screen splits and also the width and color of the splitting line. Language: Godot shader language and GDScript Renderer: Compatibility

This contains multiple plugin demos, all placed in a project for convenience. Due to GitHub issue #36713, you need to open the project to import the assets once, then close, then open: https://github.com/godotengine/godot/issues/36713 See the documentation on editor plugins for more information: https://docs.godotengine.org/en/latest/tutorials/plugins/editor/index.html How it works: This project contains 4 plugins: - The custom node plugin shows how to create a custom node type using `add_custom_type()`. - The material import plugin shows how to make a plugin handle importing a custom file type (`*.mtxt`). - The material creator plugin shows how to add a custom dock with some simple functionality. - The main screen plugin is a minimal example of how to create a plugin with a main screen. Check the `README.md` files included in each plugin's folder for more information. To use these plugins in another project, copy any of these folders to the `addons/` folder in a Godot project, and then enable them in the project settings menu. For example, the path would look like: `addons/custom_node/` Plugins can be distributed and installed from the UI. If you make a ZIP archive that contains the folder, Godot will recognize it as a plugin and will allow you to install it. This can be done via the terminal: `zip -r custom_node.zip custom_node/*` Language: GDScript Renderer: Compatibility

This is a sample showing how to use WebSockets along with the Multiplayer API in Godot: https://docs.godotengine.org/en/stable/tutorials/networking/high_level_multiplayer.html Language: GDScript Renderer: Compatibility

This is a minimal sample of connecting two peers to each other using WebSockets. Language: GDScript Renderer: Compatibility

This is a demo of a simple chat implemented using WebSockets, showing both how to host a websocket server from Godot and how to connect to it. Language: GDScript Renderer: Compatibility

This demo showcases various OS-specific features in Godot. It can be used to test Godot while porting it to a new platform or to check for regressions. In a nutshell, this demo shows how you can get information from the operating system, or interact with the operating system. How it works: The OS singleton provides an abstraction layer over the platform-dependent code. OS wraps the most common functionality to communicate with the host operating system, such as the clipboard, video driver, environment variables, execution of binaries, command line, etc. The Time singleton is used to access system date and time. The buttons are connected to a node with the `actions.gd` script, which perform actions using the OS class. The text on the left is filled in using the `os_test.gd` script, which gathers information about the OS using the OS class. On a Mono-enabled version of Godot, Godot will load `MonoTest.cs` into the `MonoTest` node. Then, information determined by C# preprocessor defines will be added to the left panel. Language: GDScript and some C# (a .NET build is *not* required to run this demo) Renderer: Compatibility