# godot-rust/gdext

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/godot-rust-gdext).**

4,912 stars · 298 forks · Rust · MPL-2.0

## Links

- GitHub: https://github.com/godot-rust/gdext
- Homepage: https://bsky.app/profile/godot-rust.bsky.social
- awesome-repositories: https://awesome-repositories.com/repository/godot-rust-gdext.md

## Topics

`game-development` `gamedev` `godot` `rust`

## Description

gdext provides a set of language bindings for writing high-performance native game logic in Rust for the Godot 4 engine. It serves as a framework for creating native engine extensions and custom classes via the GDExtension library, allowing developers to extend core engine functionality without recompiling the engine source code.

The project includes a dedicated Rust WebAssembly toolchain to compile native logic into modules for execution in web browsers. This system supports WebAssembly-compatible compilation with specific configurations for web threading and module debugging.

The toolkit covers a broad range of engine integration capabilities, including custom class definitions, scene tree node management, and type-safe signal handling. It provides utilities for physics simulation, procedural content generation, and the development of custom editor plugins.

Development is supported by automation tools for project setup, native extension testing, and logic unit testing.

## Tags

### Programming Languages & Runtimes

- [Native Engine Extensions](https://awesome-repositories.com/f/programming-languages-runtimes/c-library-embedding/runtime-embedding/webassembly-engine-embedding/javascript-engine-embedding/native-c-extension-apis/native-engine-extensions.md) — Provides a framework for creating native engine extensions and custom classes without recompiling the core engine source. ([source](https://github.com/godot-rust/gdext/blob/master/ReadMe.md))
- [GDExtension Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/gdextension-implementations.md) — Provides a framework for creating native engine extensions and custom classes using the GDExtension API.
- [C API Rust Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/c-api-rust-bindings.md) — Provides language bindings that expose low-level C APIs to allow Rust to extend core engine classes.
- [Class Method Overrides](https://awesome-repositories.com/f/programming-languages-runtimes/class-method-overrides.md) — Implements a mechanism to override core engine class functions to customize default behaviors via a stable interface. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Data Type Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/data-type-conversions.md) — Provides utilities for transforming native Rust types into specialized Godot data structures like vectors and packed arrays. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Variant-Based Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/data-type-conversions/variant-based-conversions.md) — Translates between Rust types and the engine's universal data container for seamless property and argument passing.
- [Dynamic Dispatch Mechanisms](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-dispatch-mechanisms.md) — Manages runtime polymorphism and class inheritance through smart pointers and dynamic casting logic. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Foreign Function Interfaces](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/foreign-function-interfaces.md) — Implements binding layers for low-overhead communication and data exchange between Rust and the engine's C-compatible signatures.
- [Type-Safe Pointer Wrappers](https://awesome-repositories.com/f/programming-languages-runtimes/native-runtime-wrappers/type-safe-pointer-wrappers.md) — Manages native pointers with casting logic to maintain type safety during runtime class inheritance in the engine.
- [Rust WebAssembly Integrations](https://awesome-repositories.com/f/programming-languages-runtimes/rust-webassembly-integrations.md) — Includes a dedicated toolchain for compiling native game logic into WebAssembly modules for browser execution.
- [Inheritance-Aware Smart Pointers](https://awesome-repositories.com/f/programming-languages-runtimes/smart-pointer-allocations/cross-language-smart-pointer-bridges/inheritance-aware-smart-pointers.md) — Wraps native pointers in smart pointers with casting logic to maintain type safety during runtime class inheritance.
- [Asynchronous Processing](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/asynchronous-processing/asynchronous-processing.md) — Enables non-blocking execution of event signal processing using asynchronous syntax to maintain engine responsiveness. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Multi-threaded Execution](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/execution-models/multi-threaded-execution.md) — Provides concurrency support and synchronization mechanisms for managing shared instance access during logic execution. ([source](https://godot-rust.github.io/docs/gdext))
- [Web Threading Models](https://awesome-repositories.com/f/programming-languages-runtimes/web-threading-models.md) — Supports separate single-threaded and multi-threaded builds to ensure compatibility across different browser environments. ([source](https://godot-rust.github.io/book/toolchain/export-web.html))
- [Wasm Development Toolchains](https://awesome-repositories.com/f/programming-languages-runtimes/webassembly-glue-code-generators/wasm-development-toolchains.md) — Provides a toolchain for compiling native game logic into WebAssembly modules for execution in web browsers.

### Game Development

- [Macro-Based Type Registrations](https://awesome-repositories.com/f/game-development/custom-component-type-registrations/macro-based-type-registrations.md) — Uses compile-time macros to automatically generate the boilerplate code required for registering classes and methods with the engine.
- [Godot Rust Bindings](https://awesome-repositories.com/f/game-development/godot-rust-bindings.md) — Provides high-performance Rust language bindings for writing native game logic in Godot 4.
- [Native Engine Extensions](https://awesome-repositories.com/f/game-development/native-engine-extensions.md) — Provides a toolkit for developing high-performance native extensions, physics simulations, and editor plugins.
- [Scene Tree Manipulations](https://awesome-repositories.com/f/game-development/scene-tree-manipulations.md) — Provides utilities for initializing and accessing child nodes within the scene tree to manipulate objects and UI. ([source](https://github.com/godot-rust/gdext#readme))
- [Editor Plugins](https://awesome-repositories.com/f/game-development/editor-plugins.md) — Provides a framework for creating custom tools and extensions that integrate directly into the game engine editor. ([source](https://godot-rust.github.io/))
- [Physics Simulations](https://awesome-repositories.com/f/game-development/physics-simulations.md) — Integrates with 2D and 3D physics engines to calculate complex collision and movement dynamics. ([source](https://godot-rust.github.io/book/ecosystem))
- [Infinite Terrain Generators](https://awesome-repositories.com/f/game-development/tooling-asset-pipeline/procedural-generation/infinite-terrain-generators.md) — Provides algorithmic tools for creating deterministic 3D terrains and landscapes using procedural noise. ([source](https://godot-rust.github.io/book/ecosystem))

### Software Engineering & Architecture

- [Custom Signal Definitions](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/event-driven-signal-systems/custom-signal-definitions.md) — Provides a mechanism to create typed event signals that emit notifications to listeners with controlled visibility. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Type-Safe Event Contracts](https://awesome-repositories.com/f/software-engineering-architecture/event-dispatchers/type-safe-event-contracts.md) — Implements type-safe callbacks for connecting to engine events to trigger native logic during state changes. ([source](https://github.com/godot-rust/gdext#readme))
- [Engine Event Listeners](https://awesome-repositories.com/f/software-engineering-architecture/middleware/connection-lifecycle/event-reactions/engine-event-listeners.md) — Implements type-safe listeners that trigger native logic in response to built-in engine signals. ([source](https://github.com/godot-rust/gdext/blob/master/ReadMe.md))
- [Scripting Interop](https://awesome-repositories.com/f/software-engineering-architecture/upgradeable-contract-components/method-exposure-patterns/scripting-interop.md) — Implements a registration system that makes native Rust functions callable from the Godot scripting environment. ([source](https://github.com/godot-rust/gdext/blob/master/ReadMe.md))
- [Asynchronous Task Managers](https://awesome-repositories.com/f/software-engineering-architecture/asynchronous-task-managers.md) — Supports non-blocking operations using coroutines and runtime environments to maintain application responsiveness. ([source](https://godot-rust.github.io/book/ecosystem))
- [Node-Attached Scripting Systems](https://awesome-repositories.com/f/software-engineering-architecture/extensible-plugin-architectures/scriptable-plugin-architectures/node-attached-scripting-systems.md) — Allows binding native Rust scripts directly to engine nodes to implement custom behavior without recompiling the core. ([source](https://godot-rust.github.io/book/ecosystem))
- [Function Pointer Lazy Loading](https://awesome-repositories.com/f/software-engineering-architecture/function-execution-engines/just-in-time-compilers/startup-optimizers/function-pointer-lazy-loading.md) — Reduces initial memory usage and startup time by deferring the loading of engine function pointers. ([source](https://godot-rust.github.io/docs/gdext))
- [Singleton Patterns](https://awesome-repositories.com/f/software-engineering-architecture/object-instantiation-restrictions/singleton-patterns.md) — Implements a system for defining global objects and autoloads to maintain consistent state across the application. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))
- [Deferred Function Loading](https://awesome-repositories.com/f/software-engineering-architecture/plugin-architectures/programmatic-plugin-loading/lazy-loading/deferred-function-loading.md) — Reduces initial memory usage and startup time by deferring the loading of engine function pointers until they are first used.
- [Procedural Content Generation](https://awesome-repositories.com/f/software-engineering-architecture/procedural-content-generation.md) — Provides algorithmic frameworks for creating dynamic game worlds and environments. ([source](https://godot-rust.github.io/book/ecosystem))

### User Interface & Experience

- [Engine Loop Callbacks](https://awesome-repositories.com/f/user-interface-experience/main-thread-dispatchers/engine-loop-callbacks.md) — Provides hooks to execute custom native logic on every frame or physics tick within the primary engine loop. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))

### Web Development

- [WebAssembly Exports](https://awesome-repositories.com/f/web-development/webassembly-exports.md) — Provides toolchains to compile native game logic into WebAssembly modules for execution in web browsers. ([source](https://godot-rust.github.io/docs/gdext))

### Artificial Intelligence & ML

- [Interactive Narratives](https://awesome-repositories.com/f/artificial-intelligence-ml/ai-driven-content-modeling/interactive-narratives.md) — Integrates local large language models to generate dynamic, AI-driven narratives and interactive storytelling. ([source](https://godot-rust.github.io/book/ecosystem))

### Development Tools & Productivity

- [Inspector Variable Exposure](https://awesome-repositories.com/f/development-tools-productivity/inspector-variable-exposure.md) — Provides attributes to mark Rust fields as editable within the visual property inspector for real-time tuning. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))

### Networking & Communication

- [Type-Safe Remote Calls](https://awesome-repositories.com/f/networking-communication/remote-procedure-calls/type-safe-remote-calls.md) — Implements remote procedure calls with strong typing for coordinated logic execution across networked game clients. ([source](https://github.com/godot-rust/gdext/blob/master/Changelog.md))