awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
godotengine avatar

godotengine/godot-cpp

0
View on GitHub↗
2,558 stars·777 forks·C++·MIT·29 viewsdocs.godotengine.org/en/latest/tutorials/scripting/cpp↗

Godot Cpp

godot-cpp is a C++ binding library and development kit for creating high-performance extensions and custom nodes for the Godot engine. It provides the necessary headers and framework to implement complex game logic and low-level systems using native code.

The project enables the development of GDExtension plugins, allowing native libraries to be loaded into the engine without requiring a full recompilation of the core software. It facilitates the creation of custom engine extensions through a system of native bindings that map C++ classes and methods to the internal engine database.

The framework covers API integration via class registration and signal binding, as well as editor integration for exposing member variables. It includes a CMake-based build system for multi-platform targeting, supporting cross-compilation for desktop, Android, and WebAssembly via Emscripten.

The build process incorporates integration testing and the generation of compilation databases for IDE support.

Features

  • Engine Modules and Extensions - Enables the addition of new node types and specialized functionality to the engine using native C++ code.
  • C Function Bindings - Implements a native binding layer that maps C++ classes and methods to the engine's internal database.
  • Variant Data Types - Provides specialized array types and generic variant classes to maintain data compatibility between native code and the engine API.
  • Plugin Development Kits - Offers a specialized toolset for developing native plugins that integrate with the engine without full recompilation.
  • Native Performance Logic - Implements complex game systems in C++ to achieve better execution speed than standard scripting languages.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Native Engine Extensions - Allows compiling extensions into separate libraries that load into the editor or projects without full software recompilation.
  • C++ Container Exposures to Script - Exposes C++ classes and methods to the engine's signal and property system for editor access.
  • Runtime Signal Binding - Allows native C++ methods to be bound to emitted signals to trigger reactions to external events.
  • Engine Class Registrations - Allows native C++ classes to be registered within the engine for use in scripts and editor dialogs.
  • Native Class Subclassing - Supports inheriting from native engine classes to implement custom node functionality in C++.
  • Class Hierarchies - Organizes native types into a class hierarchy that inherits from base engine classes for scene integration.
  • Lifecycle Method Overrides - Enables overriding specific lifecycle methods to execute native C++ code during engine frames or events.
  • Engine Binding Libraries - Provides a set of C++ headers and bindings for creating high-performance extensions and custom nodes for the Godot engine.
  • C++ Engine Extensions - Provides a framework for implementing performance-critical game logic in C++ and exposing it via a bridge API.
  • Custom Signal Definitions - Enables the definition and emission of custom event signals to facilitate communication between objects and scripts.
  • Native Plugin Development - Provides a toolkit for building native libraries that interface directly with the host engine's core runtime.
  • Internal Object Extensions - Enables the creation of custom object instances that integrate directly into the engine's core object hierarchy.
  • Pluggable Module Loading - Supports compiling logic into shared libraries that are dynamically loaded by the engine at runtime.
  • Cross-Platform Build Systems - Uses a CMake-based build configuration to manage cross-platform compilation for Android, Web, and desktop.
  • Multi-Target Build Orchestrators - Utilizes a multi-target CMake orchestrator to manage toolchains across different operating systems and compilers.
  • Cross-Platform and Native Compilation - Builds native extensions for various operating systems including Windows, Android, and Web.
  • Android NDK Configurations - Includes Android NDK configurations to enable cross-compiling extensions for Android devices from Windows.
  • Cross-Platform Build Systems - Automates the compilation and packaging of native extensions for multiple target operating systems.
  • Internal API Access - Provides access to internal engine APIs for implementing high-performance logic and low-level data operations.
  • Emscripten Support - Provides integrated toolchain support for compiling C++ extensions to WebAssembly via Emscripten.
  • API Configuration Mappings - Uses configuration mappings to synchronize C++ headers with specific internal engine API versions.
  • Cross-Version Compatibility Gating - Provides mechanisms to ensure compiled native extensions remain compatible across multiple minor versions of the engine.
  • Property Editor Registration APIs - Provides APIs to register native member variables as editable properties within the engine's user interface.
  • WebAssembly Compilation - Integrates with the Emscripten toolchain to compile C++ code into WebAssembly binaries for browser execution.
  • Media & Communication - Bindings for Godot script API

    • Star history

    Star history chart for godotengine/godot-cppStar history chart for godotengine/godot-cpp

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does godotengine/godot-cpp do?

    godot-cpp is a C++ binding library and development kit for creating high-performance extensions and custom nodes for the Godot engine. It provides the necessary headers and framework to implement complex game logic and low-level systems using native code.

    What are the main features of godotengine/godot-cpp?

    The main features of godotengine/godot-cpp are: Engine Modules and Extensions, C Function Bindings, Variant Data Types, Plugin Development Kits, Native Performance Logic, Native Engine Extensions, C++ Container Exposures to Script, Runtime Signal Binding.

    Which projects share features with godotengine/godot-cpp?

    Projects with overlapping indexed features include: godotengine/godot-demo-projects — This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the… crystal-lang/crystal — Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It… nim-lang/nim — Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform… premake/premake-core — Premake is a build system generator and cross-platform build configuration tool. It functions as a scripting engine… android/ndk-samples — The Android NDK samples provide a comprehensive collection of code examples demonstrating how to integrate C and C++… godot-rust/gdext — gdext provides a set of language bindings for writing high-performance native game logic in Rust for the Godot 4…

    Projects sharing features with Godot Cpp

    These projects share indexed features with Godot Cpp. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • godotengine/godot-demo-projectsgodotengine avatar

      godotengine/godot-demo-projects

      8,250View on GitHub↗

      This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

      GDScript
      View on GitHub↗8,250
    • crystal-lang/crystalcrystal-lang avatar

      crystal-lang/crystal

      20,299View on GitHub↗

      Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

      Crystalcompilercrystalcrystal-language
      View on GitHub↗20,299
    • nim-lang/nimnim-lang avatar

      nim-lang/Nim

      18,071View on GitHub↗

      Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

      Nimcompilerefficienthacktoberfest
      View on GitHub↗18,071
    • premake/premake-corepremake avatar

      premake/premake-core

      3,566View on GitHub↗

      Premake is a build system generator and cross-platform build configuration tool. It functions as a scripting engine that transforms scripted workspace definitions into native project files for multiple build toolsets and compilers. Additionally, it can generate JSON-formatted compilation databases for use with language servers and static analysis tools. The project distinguishes itself through a programmable runtime that allows for internal function hooking and the interception of build logic. This extensibility enables users to create custom toolset generators, implement modular extensions f

      Cchacktoberfestlua
      View on GitHub↗3,566
    Compare all 30 related projects→