project_structure_dotnet_godot

Organize .NET 8+ and Godot 4.x solutions with Core and Client separation.

2|Updated Jul 2, 2026
One-click install
npx skills add https://github.com/Xyrces/godot-ecs-gamedev-playbook --skill project-structure-dotnet-godot
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: project_structure_dotnet_godot
Source: https://github.com/Xyrces/godot-ecs-gamedev-playbook/tree/main/skills/project_structure_dotnet_godot
Command: npx skills add https://github.com/Xyrces/godot-ecs-gamedev-playbook --skill project-structure-dotnet-godot

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill defines a consistent project structure for Godot 4.x games built with .NET 8+ and an engine-agnostic ECS architecture, preventing tangled dependencies and inconsistent solution layouts.

Core Features & Use Cases

  • Solution Layout Guidance: Organizes Core, Client, tests, and benchmarks into a maintainable directory and solution structure.
  • Build and Package Configuration: Standardizes global.json, Directory.Build.props, and central NuGet package management for reproducible builds.
  • Godot and ECS Separation: Keeps pure C# gameplay logic isolated from Godot-specific presentation, input, audio, and scene management.
  • CI and Testability: Supports fast validation of Core logic and architecture rules without requiring the Godot editor for every build.
  • Use Case: Set up a new game repository so gameplay code is testable in isolation while the Godot client handles rendering and platform integration.

Quick Start

Ask for a .NET 8 plus Godot 4 project layout that separates Core ECS logic from the Client, includes test and benchmark projects, and follows the canonical folder and build configuration described in this skill.

Frequently Asked Questions about project_structure_dotnet_godot

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a .NET Godot project to keep ECS gameplay logic separate from the engine?

To structure a .NET Godot project with isolated ECS logic, you separate the solution into a Core project for pure C# gameplay and a Client project for Godot-specific rendering and scenes. This keeps gameplay code independent from the engine.

What is the best way to organize a Godot 4.x .NET 8 solution for testable game architecture?

The best way to organize a Godot .NET solution for testability is creating distinct Core, Client, test, and benchmark projects. This layout allows fast validation of Core ECS logic through CI pipelines without requiring the Godot editor for every build.

Does Godot 4.x support central package management and shared build properties for .NET 8?

Godot 4.x supports central package management and shared build properties for .NET 8 through standard files like global.json and Directory.Build.props. Standardizing these configurations ensures reproducible builds across your game repository.

How do I set up CI pipelines for a Godot .NET game without launching the editor?

You set up CI pipelines for a Godot .NET game by configuring validation paths that test the Core ECS logic independently. Separating pure C# gameplay code from the Godot Client allows fast automated testing without launching the Godot editor.

Can I test Godot gameplay code in isolation using an engine-agnostic ECS approach?

You can test Godot gameplay code in isolation by adopting an engine-agnostic ECS architecture that separates pure C# logic into a Core project. This Core project runs validation paths independently from Godot-specific presentation and scene management.

Why does my Godot .NET solution layout have tangled dependencies between gameplay and presentation code?

Godot .NET solution layouts have tangled dependencies when gameplay and presentation code are mixed. Applying a Core and Client separation structure isolates engine-agnostic ECS logic from Godot-specific input, audio, and scene management to prevent this.