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.
More features and modules are in development and refinement! Check the repository for updates.
Ascendere follows these principles:
Ascendere is perfect for:
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.
addons/ascendere folder into your Godot projectโs addons/ directoryThatโ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:
[Service] attribute๐ Full Service Locator Documentation
Type-safe, attribute-based event system with native Godot signal integration.
Features:
// 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/awaitGameScene base class for elegant flow controlLauncherScene for requirement validation// 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:
[RegistryEntry] attribute// 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:
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:
[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:
[Module] attribute[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:
UIBuilder.CreateVBox/HBox(), CreateCenteredVBox(), CreateHeader(), CreateCard(), CreateControlGroup(), CreateNavigationBar(), and moreSceneBuilder.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.
[SceneDSL] to expose it as a one-click toolbar actionSceneBuilder.RegisterTemplate(); pick from the menu to generate a scene file with pre-configured nodes, scripts, and paths[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.
RuntimeMessage and implement IMessageHandler<T> for domain-specific commandsRuntimeBridge, 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
}
}
#endif
Tools 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() { /* ... */ }
}
#endif
Both 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:
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.