CrimsonCommonv1.0Free
Get it on Fab

An optional, standalone toolbox: message bus, player classes, modular actors and editor tools. No Crimson plugin requires it.

Free · Toolbox · Unreal Engine 5

An optional toolbox. Take what you need; no plugin requires it.

A gameplay-tag message bus, CommonGame-style player classes with session and user subsystems, Game-Feature-ready modular actors, logging macros, and editor tools including the in-editor Crimson wiki. Every Crimson plugin runs without it; enable it for the pieces your project wants.

Why CrimsonCommon

Independent, opt-in pieces you would otherwise write yourself. Use one, use all, or skip it entirely.

Nothing depends on it

Every Crimson plugin builds and runs on its own with only engine plugins. CrimsonCommon is a toolbox you enable when one of its pieces saves you work, not a foundation you must install first.

Modular base classes

Game-Feature-ready Character, Pawn, Player Controller, Player State, Game Mode/State and AI Controller bases register as ModularGameplay component receivers, so Game Feature actions can add components at runtime. A drop-in for Epic's ModularGameplayActors.

Tag-routed message bus

UCrimsonMessageSubsystem sends struct payloads on gameplay-tag channels with exact or partial matching, so sender and receiver never reference each other. Blueprint gets Listen For Crimson Messages and Broadcast Message nodes.

CommonGame-style player classes

A game instance, local player and player controller that raise reliable controller, player state and pawn set delegates. CallAndRegister_* fires at once when the object already exists, so late binders never miss the event.

Session and user subsystems

UCrimsonSessionSubsystem hosts, finds and joins sessions. UCrimsonUserSubsystem handles login, privileges and the player lifecycle, on OSSv1 or OSSv2 through a compile-time switch.

Editor tools

The in-editor Crimson wiki renders the docs for every Crimson plugin. Alongside it: the DevTools Gallery, a Common Maps toolbar dropdown for the levels you open most, and a widget authoring library that prunes dead animation bindings.

A closer look

Enable it in a minute, remove it just as fast

Tick CrimsonCommon in Edit → Plugins and restart. Blueprint projects need nothing else; C++ projects add one module line. No other Crimson plugin pulls it in or breaks without it.

  • The Crimson Wiki button appears on the Level Editor toolbar
  • Crimson.DevTools.Gallery opens the dev-tool component gallery
  • The player classes and modular actors are optional extra steps

One channel tree for events from many systems

Every Crimson plugin reports its events through delegates on the object that owns them. When you would rather listen in one place, forward those delegates onto the bus and subscribe by tag.

  • Exact or partial matching: listen to a channel or its whole subtree
  • Blueprint Broadcast Message takes any struct payload
  • The bus is local to one game instance; it does not replicate

Player lifecycle events you can bind late

The engine has no clean "player state arrived" event. UCrimsonCommonLocalPlayer raises controller, player state and pawn set delegates, and the session and user subsystems use these classes to follow each player.

  • UCrimsonCommonGameInstance is abstract: subclass it in Blueprint or C++
  • ACrimsonCommonPlayerController raises the three local-player delegates

Adopt incrementally: it's a toolbox, not a pipeline

Every piece is independent and opt-in: reparent the Character today and the Player State later, use the message bus without the player classes, or enable the plugin only for the wiki and editor tools. Take only what your game needs.

Technical details

Engine
UE 5.8
Tested platforms
Windows
Blueprint-ready
Yes
C++ required
No
Network replicated
No
Dependencies
ModularGameplay, GameFeatures, GameplayAbilities, EnhancedInput, CommonUI, OnlineSubsystem, OnlineSubsystemUtils, SlateIM, GameplayTagsEditor

Frequently asked questions

Is it really free?
Yes. CrimsonCommon is free.
Does it depend on other Crimson plugins?
No, and no Crimson plugin depends on it. Every Crimson plugin builds and runs on its own and talks to your project through its own delegates, interfaces and ModularGameplay feature states. CrimsonCore, the free integration layer from the Crimson Discord, uses CrimsonCommon's player classes, modular actors and session subsystem.
Do I need C++ to use it?
No. The message bus has Blueprint listen and broadcast nodes, the game instance and modular actors are reparented or subclassed in Blueprint, and the editor tools need no code. The CRIMSON_LOG_* macros and the dev-tool component library are for C++ authors.
Will adopting it change how my game runs?
No. The modular actors derive from Epic's classes and only add ModularGameplay receiver registration, so reparenting changes the base, not the behavior. Nothing here runs unless you use it.
What does it replace?
The modular actors are a drop-in for Epic's ModularGameplayActors, and the player classes with the session and user subsystems follow Epic's CommonGame and CommonUser pattern.

Take the pieces you want

CrimsonCommon is free and fully optional. Enable it for the message bus, the player classes, the modular actors or just the in-editor wiki.