This is a Rust language binding for the Godot 4 game engine, implemented as a GDExtension library. The repository provides a comprehensive, safe, and idiomatic Rust API to define Godot classes, methods, signals, properties, and async tasks. It consists of multiple interdependent crates: `godot-bindings` for locating the Godot binary and loading API JSON, `godot-codegen` for generating Rust FFI wrappers and core mappings from Godot's extension API, `godot-core` containing built-in type wrappers (Variant, Vector2/3/4, Color, Basis, etc.), object model (`Gd<T>`, `Base<T>`, `DynGd<T>`), signal system, property registration, and conversions, `godot-ffi` for low-level FFI type definitions and binding storage, `godot-macros` providing procedural macros (`#[derive(GodotClass)]`, `#[godot_api]`, `#[func]`, `#[signal]`, `#[var]`, `#[export]`), and `godot-cell` for safe interior mutability (`GdCell`). The codebase is heavily code-generated, extensively integration-tested inside a real Godot process, and includes benchmarks, hot-reload support, and a complex build pipeline. It is a tightly coupled framework that mimics Godot's object-oriented model in Rust with careful safety and thread-safety considerations. The design shows high craftsmanship in FFI abstraction, type conversion traits, and macro-driven registration, but also carries technical debt due to version-specific conditional compilation and deep dependencies on Godot's runtime layout.
This repository is a Godot 4 addon that integrates the libsm64 library (a reimplementation of Super Mario 64's game engine) into Godot via GDExtension. It provides both a low-level C++ API exposed as a Godot singleton (`LibSM64`) and high-level GDScript nodes (`LibSM64Mario`, `LibSM64StaticSurfaceHandler`, `LibSM64SurfaceObjectsHandler`, `LibSM64AudioStreamPlayer`) for easily adding Mario characters and surface geometry to Godot scenes. The addon handles coordinate system conversion (SM64 to Godot), fixed-rate physics ticking at 30 FPS with interpolation for smooth rendering, and dynamic material switching based on Mario's power-up state. A demo project with multiple playable scenarios (Bob-omb Battlefield, many Marios, flying range) is included, along with a ROM picker dialog for loading the required Super Mario 64 US ROM. The architecture is a classic Godot plugin: a GDExtension shared library (built from C++ source in `extension/`) registers new engine classes and a singleton, while GDScript files in `addons/libsm64_godot/` provide editor integration and higher-level abstractions. The core C++ code wraps all libsm64 functions (global init, Mario creation/tick, surface loading, audio) and exposes them as Godot methods. The GDScript layer adds node lifecycle management, input mapping, interpolation, and surface handling utilities. The demo project in `libsm64_godot_demo/` showcases the addon with custom scenes, a camera rig, HUD, and input configuration. Key external dependencies are the libsm64 C library (included as a Git submodule) and the godot-cpp bindings (also a submodule). The addon requires a specific Super Mario 64 US ROM (SHA-256 verified) to function, as libsm64 uses original game assets. The build system uses SCons and GitHub Actions to compile the GDExtension for Windows, macOS, Linux, and Web platforms. The code is well-structured with clear separation between C++ engine bindings and GDScript gameplay logic, making it a solid reference for integrating complex C libraries into Godot.
This repository is a Godot GDExtension that enables using Dart as a scripting language for the Godot game engine. It provides a C++ native plugin that embeds the Dart VM, a Dart runtime library (`godot_dart`) with FFI bindings and type wrappers, and a build runner package (`godot_dart_build`) for generating boilerplate code from `@GodotScript` annotations. A binding generator tool (`tools/binding_generator`) reads Godot's extension API JSON to produce Dart bindings for engine classes and built-in types. The repo includes two example projects: a 2D game tutorial and a networking demo. It is feature-rich but explicitly experimental, with partial support for debugging, hot reload, and editor integration, and acknowledges that performance optimization has not yet been performed. The architecture is a hybrid of C++ native extension and Dart packages with code generation pipelines, making it a complex but well-structured integration layer between the Godot engine and the Dart language.