Architecture Ready for Unreal Engine and Godot

GameCatalyst’s architecture is designed to support multiple engines without changing the core system. This isn’t a theoretical claim—the directory structure, abstraction layers, and handler system are already in place, waiting for engine-specific implementations. When Unreal and Godot support launches, you’ll use the same Dashboard, the same AI clients, and the same core workflows you learned with Unity.

Current support:

• Unity — Full support (Unity 6000.3.10 or newer) with 60+ commands across 8 categories
• Unreal Engine — Structure-ready, handler-based architecture prepared for integration. Directory placeholders exist. Command framework ready.
• Godot — Structure-ready, handler-based architecture prepared for integration. Directory placeholders exist. Command framework ready.

What “structure-ready” means:

The orchestration layer (Layers 1-3) is completely engine-agnostic. These layers handle AI client communication, session management, and command routing without knowing which engine you’re using. Only Layer 4 (Engine Instance Server) and Layer 5 (Engine API Bridge) are engine-specific, and they follow a standardized interface that works the same way regardless of the underlying engine.

To add Unreal support, Vexstorm Studios will:

1. Create an Unreal Instance Server (Python, Layer 4) — This server runs outside Unreal Editor and manages project registration, heartbeat monitoring, and command forwarding
2. Create an Unreal API Bridge (C++, Layer 5) — This component lives inside Unreal Editor and executes commands on the main thread
3. Implement Unreal-specific handlers — Blueprint creation, Actor spawning, Component attachment, Material assignment, etc.
4. Create CommandDefinition assets for Unreal commands — Define actor.spawn, blueprint.create, component.attach, and other Unreal-specific commands
5. Test and validate — Ensure all safety features, permissions, and workflows function correctly

The MCP Bridge, Discovery Server, Conductor, and all AI client integrations remain unchanged. Your AI client doesn’t know or care which engine you’re using. It just sees available commands and executes them.

Directory structure already exists:

In the Central Installation Directory (CID), you’ll find engine adapter folders:

• EngineAdapters/Unity/ — Fully implemented with UnityInstanceServer.py, command handlers, and configuration
• EngineAdapters/Unreal/ — Placeholder directory with README explaining future implementation
• EngineAdapters/Godot/ — Placeholder directory with README explaining future implementation

This structure isn’t accidental. It’s deliberate architectural planning that makes multi-engine support a matter of implementation, not redesign.

Timeline for Unreal and Godot support:

Vexstorm Studios hasn’t announced specific release dates for Unreal and Godot support. The architecture is ready, but implementation requires significant development and testing. Follow Vexstorm Studios announcements for updates.

What this means for you today:

Even if you only use Unity, the engine-agnostic architecture benefits you:

• Clean separation of concerns makes the codebase more maintainable
• Standardized interfaces mean fewer bugs
• Future-proof design ensures your investment in learning GameCatalyst transfers to other engines

When Unreal or Godot support launches, you won’t need to relearn GameCatalyst. You’ll already know how it works.