The Godot MetaFramework - A modular, production-ready framework for building scalable games in Godot 4.x with C#
Ascendere is a comprehensive metaframework that provides everything you need to build professional games with Godot and C#. From service locators and event systems to scene management and debugging tools, Ascendere offers a cohesive ecosystem of battle-tested modules that work seamlessly together.
- ๐ Plug-and-Play Modules - Modular architecture with auto-discovery
- ๐ฏ Service Locator - Dependency injection with automatic service discovery
- ๐ก Event Bus - Type-safe event system with native Godot signal integration
- ๐ฌ Scene Manager - Elegant scene transitions with history and preloading
- ๐ฆ Registry System - Type-safe data management for items, entities, and more
- ๐ Debug System - Comprehensive runtime debugging tools
- ๐ Logger - Attribute-based logging with configurable levels
- ๐๏ธ Fluent APIs - Every major module exposes a chainable fluent builder so you write intent, not boilerplate
- โ๏ธ Editor Extensions - Command palette, Scene DSL, live editor-runtime bridge, and workflow tools
- ๐ฎ Game Modules - AI, Inventory, Networking, Quests, SaveLoad, and more
More features and modules are in development and refinement! Check the repository for updates.
Ascendere follows these principles:
- Modular First - Everything is a module that can be extended, tweaked, or replaced
- Godot-Native - It's an Addon that integrates directly with Godot with no external dependencies
- Auto-Discovery - Use attributes, minimal boilerplate
- Convention Over Configuration - Sensible defaults, configure only when needed
- Dependency Injection - Services are injected, not manually instantiated
- Declarative Style - Self-describing code with clear patterns
- Type Safety - Generics and interfaces prevent bugs
Ascendere is perfect for:
- ๐ฎ Mid to large-scale games requiring proper architecture
- ๐ฅ Team projects where consistency and clarity matter
- ๐ Long-term projects that need maintainability
- ๐ Learning modern C# game development patterns
- ๐ Rapid prototyping with production-ready systems
A meta-framework is a higher-level framework that integrates or builds upon existing framework to provide a more cohesive, opinionated, and feature-rich development environment.
Ascendere is a metaframework that combines core architecture, powerful features and tools, reusable systems, and clear conventions for building games on top of Godot to help you structure, scale, and maintain projects.
Designed for team workflows and long-term development, Ascendere enables rapid prototyping while remaining production-ready.
- Clone or download this repository
- Copy the
addons/ascenderefolder into your Godot project'saddons/directory - Open your project in Godot
- Go to Project โ Project Settings โ Plugins
- Enable the Ascendere plugin
That's it! Ascendere will automatically initialize its core systems.
using Ascendere;
// 1. Define an interface
public interface IScoreService
{
int Score { get; }
void AddPoints(int points);
}
// 2. Implement with [Service] attribute
[Service(typeof(IScoreService))]
public class ScoreService : IScoreService
{
public int Score { get; private set; }
public void AddPoints(int points)
{
Score += points;
EventBus.Instance.Publish(new ScoreChangedEvent { NewScore = Score });
}
}
// 3. Use in your nodes
public partial class Player : CharacterBody2D
{
[Inject] private IScoreService _scoreService;
public override void _Ready()
{
ServiceLocator.InjectMembers(this);
}
private void CollectCoin()
{
_scoreService?.AddPoints(10);
}
}No manual registration needed - it's all automatic! โจ
A powerful dependency injection system with automatic service discovery.
Features:
- Automatic service discovery via
[Service]attribute - Multiple lifetimes (Singleton, Transient, Scoped)
- Constructor and member injection
- Lazy loading
- Async initialization support
- Event system for service lifecycle tracking
๐ Full Service Locator Documentation
Type-safe, attribute-based event system with native Godot signal integration.
Features:
- Type-safe event handling
- Priority-based execution order
- Native Godot signal conversion
- Event filtering and debugging
- Subscribe/unsubscribe tracking
- Global and local event scopes
// Define an event
public struct PlayerDiedEvent : IEvent
{
public string PlayerName;
public Vector2 Position;
}
// Subscribe and handle
[EventHandler(typeof(PlayerDiedEvent))]
private void OnPlayerDied(PlayerDiedEvent evt)
{
GD.Print($"{evt.PlayerName} died!");
}
// Publish
EventBus.Instance.Publish(new PlayerDiedEvent
{
PlayerName = "Hero",
Position = GlobalPosition
});๐ Full Event Bus Documentation
Sophisticated scene management with transitions, history, and preloading.
Features:
- Async scene transitions with
async/await - Scene history and navigation
- Background preloading for instant transitions
GameScenebase class for elegant flow controlLauncherScenefor requirement validation- Reflection-based scene discovery
// Option 1: Elegant flow using GameScene
public partial class MenuScene : GameScene
{
protected override Type? GetNextSceneType() => typeof(GameplayScene);
private void OnPlayPressed()
{
ProceedToNext(); // Automatically transitions to GameplayScene
}
}
// Option 2: Direct scene management
await SceneManager.ChangeSceneAsync("res://scenes/game.tscn");
await SceneManager.GoBackAsync(); // Navigate backwards in history๐ Full Scene Manager Documentation
Type-safe, centralized data management for game content.
Features:
- Auto-discovery via
[RegistryEntry]attribute - Type-safe generic base prevents mixing incompatible types
- Built-in serialization (JSON and Godot Resources)
- Event system for tracking changes
- Load from files or Resources
- Hot-reloading support
// Define an item
[RegistryEntry("sword_iron")]
public class IronSword : ISerializableEntry
{
public string Id => "sword_iron";
public string Name => "Iron Sword";
public int Damage => 25;
}
// Auto-registered on startup!
var sword = ItemRegistry.Instance.Get("sword_iron");๐ Full Registry Documentation
Comprehensive runtime debugging completely decoupled from your game code.
Features:
- 3D debug drawing (lines, spheres, boxes, arrows, labels, paths, rays)
- Real-time value watching
- Custom debug windows
- Performance monitoring (FPS, memory)
- Node inspector
- Debug console with command execution
- Keyboard shortcuts (F1, F2, F3, ~)
public override void _Process(double delta)
{
// Draw velocity arrow
DebugManager.Instance.DrawArrow3D(
this,
GlobalPosition,
GlobalPosition + Velocity,
Colors.Red
);
// Watch values in real-time
DebugManager.Instance.Watch("Speed", Velocity.Length());
DebugManager.Instance.Watch("Health", _health);
}๐ Full Debug System Documentation
Lightweight, attribute-based logging with configurable output.
Features:
- Attribute-based logging control per class
- Multiple log levels (Debug, Info, Warning, Error)
- Runtime configuration
- Timestamps and type names
- Service locator integration
- Extension methods for easy usage
[Log(true)] // Enable logging for this class
public partial class MyGame : Node
{
public override void _Ready()
{
this.LogInfo("Game started!");
this.LogDebug("Loading resources...");
this.LogWarning("Low memory!");
this.LogError("Failed to load asset!");
}
}๐ Full Logger Documentation
Build and integrate your own modules with the Ascendere architecture.
Features:
- Auto-discovery via
[Module]attribute - Load order control
- Lifecycle management (Initialize/Cleanup)
- Integration with Service Locator
- Hot-reload support
[Module("MyModule", AutoLoad = true, LoadOrder = 10)]
public partial class MyModule : Node, IModule
{
public string Name => "MyModule";
public bool IsInitialized { get; private set; }
public void Initialize()
{
// Setup your module
IsInitialized = true;
}
public void Cleanup()
{
// Clean up resources
IsInitialized = false;
}
}Every major Ascendere module exposes a discoverable, chainable fluent interface. Instead of wiring nodes manually, you express what you want:
// UI โ compose whole screens without manual node plumbing
using UIModule.Core.Utils;
var panel = UIBuilder
.CreateCenteredVBox(spacing: 12, width: 400, height: 300)
.AddChild(UIBuilder.CreateHeader("Settings", fontSize: 24))
.AddChild(UIBuilder.CreateControlGroup("Master Volume", new HSlider()))
.AddChild(UIBuilder.CreateButton("Apply", OnApply));
// Scene scaffolding โ generate a fully wired scene file from code
SceneBuilder
.FromTemplate("CharacterBody3D", "Player")
.WithScript("Player.cs")
.AtPath("res://scenes/player.tscn")
.Build();Fluent builders are available for:
- UI โ
UIBuilder.CreateVBox/HBox(),CreateCenteredVBox(),CreateHeader(),CreateCard(),CreateControlGroup(),CreateNavigationBar(), and more - Scene โ
SceneBuilder.FromTemplate(),.WithScript(),.AtPath(),.Build()
Ascendere includes ready-to-use game modules:
| Module | Description |
|---|---|
| AI | Behavior trees, state machines, and AI utilities |
| Inventory | Complete inventory system with stacking and categories |
| Networking | Multiplayer functionality and network synchronization |
| Quests | Quest management with objectives and rewards |
| SaveLoad | Game state serialization and save file management |
More modules coming soon!
A DSL-driven scene scaffolding tool accessible from the Godot toolbar. Stamp complete, fully wired scenes directly into your project from reusable templates โ no manual node setup required.
- DSL Scenes โ Tag any static C# method with
[SceneDSL]to expose it as a one-click toolbar action - Templates โ Register named templates via
SceneBuilder.RegisterTemplate(); pick from the menu to generate a scene file with pre-configured nodes, scripts, and paths - Composite Templates โ Bundle multiple templates into a single action for full feature scaffolding
- Hot-Reload Safe โ Template registry is rebuilt on every plugin reload with no stale state
[SceneDSL("My Scenes/Player Scene")]
public static void CreatePlayerScene()
{
SceneBuilder
.FromTemplate("CharacterBody3D", "Player")
.WithScript("Player.cs")
.AtPath("res://scenes/player.tscn")
.Build();
}Enables live bidirectional communication between the Godot editor and the running game. Useful for hot-sending config, tweaking values without restarting, or pushing telemetry back to the editor during play.
- Runtime Data dock โ Live panel in the editor showing messages from the game
- Ping / Send โ Send arbitrary messages to the game and receive responses in real time
- Custom message types โ Extend
RuntimeMessageand implementIMessageHandler<T>for domain-specific commands - Zero game-code coupling โ The bridge is fully decoupled; game code only knows about
RuntimeBridge, not the editor
// In your game (runtime side)
public class HealPlayerHandler : IMessageHandler<HealPlayerMessage>
{
public void Handle(HealPlayerMessage msg, RuntimeBridge bridge)
{
Player.Instance.Heal(msg.Amount);
bridge.Send(new AckMessage { Ok = true });
}
}Ascendere provides code-level building blocks so you can extend the editor's own command palette and tools menu with your own commands โ all discovered automatically, no wiring required.
Command Palette โ Tag any static method with [EditorCommand] and it appears in Godot's native Ctrl+Shift+P palette, organised by category:
#if TOOLS
[EditorCommandProvider]
public static class MyProjectCommands
{
[EditorCommand("Reset Player Position",
Description = "Teleports player to origin",
Category = "Debug",
Priority = 50)]
public static void ResetPlayerPosition()
{
// runs in the editor context
}
}
#endifTools Menu โ Register custom menu items that appear under the Godot toolbar's Project โ Tools dropdown:
#if TOOLS
[EditorToolsProvider]
public static class MyTools
{
[EditorTool("Generate Navmesh", Category = "World")]
public static void BakeNavmesh() { /* ... */ }
}
#endifBoth systems use the same auto-discovery pattern: the CommandPaletteManager scans assemblies at plugin load and registers everything it finds โ no AddChild, no manual subscriptions, no cleanup code needed.
Each module has comprehensive documentation:
- Service Locator - Full API reference and examples
- Event Bus - Event system guide
- Scene Manager - Scene flow patterns
- Registry System - Integration guide
- Debug System - Debugging tools reference
- Logger - Logging configuration
- Camera Module - Virtual cameras, blending, fluent API
- Audio Module - Full audio pipeline reference
- Editor Runtime - Editor-game bridge
To help you migrate an existing Godot/C# project into Ascendere, the migration guide walks through the most common patterns (singleton managers, scene switching, static data, etc.) and shows how to replace them with Ascendere equivalents. Read it at MIGRATION_GUIDE.md.
Ascendere uses Adapters to safely connect modules without creating direct dependencies between them. They live in addons/ascendere/Adapters/ and are documented in ADAPTERS.md.
Ascendere is licensed under the Ascendere Community License (ACL-1.0). That means you are free to use, modify, and ship Ascendere inside your games (including commercial titles), but you may not redistribute the framework itself as a standalone addon/library or rebrand it without permission. See the full terms in LICENSE.
Note: Premium/paid modules (e.g. UI Kit Pro) are governed by a separate commercial license.