CrimsonSkillTreev2.0Personal $39.99 · Professional $69.99
Get it on Fab

Replicated, GAS-integrated skill trees authored in a two-graph editor, with connections you shape by hand.

Gameplay · Unreal Engine 5

Ship skill trees that just work: replicated, GAS-native, designer-friendly.

Author each tree in a two-graph editor with a live UMG preview of every node, bend each connection into the exact curve you want, and let the server-authoritative runtime handle replication, point budgets, atomic respec, and loadouts.

Why CrimsonSkillTree

Everything you need to design, ship, and maintain progression systems.

Two-graph authoring

Separate the Logic Graph (nodes, dependencies, conditions, events, costs) from the Visual Graph (layout, per-node widget overrides, decorations), with a live UMG preview of every node, rendered through the same entry point the game uses.

Connections you shape by hand

Click a line in the Visual graph and bend it: add keys, drag tangent handles, or open the Connection Curve tab, Unreal's curve editor bound to that line. Ends stay pinned to the node anchors; per-line brush overrides run a material along the strip.

Lines that react to state

Every connection resolves a state (Locked, Unlockable, Active, Maxed) and looks up a per-state style. Buying a node fills its incoming line parent-to-child; style changes crossfade. One connection-layer widget paints them all, so panning costs nothing and no state change spawns a widget.

Server-authoritative runtime

Delta-only FastArray replication for node state and resource budgets, validated Server_ RPCs for every player action, atomic all-or-nothing batches, atomic respec, and named loadouts.

A save struct you own

State is exposed as plain BlueprintType structs: read them with GetAllSkillTreesSaveData, write them back with ApplyAllSkillTreesSaveData. The plugin ships no persistence of its own and has no hard dependency on any save system.

Tooling that catches mistakes

Eleven compile-time validators with double-click jump-to-node, a PIE debugger that tints Logic nodes by live runtime state, and a Skill Tree Dev Tools window that inspects and drives a running tree: per-node actions, resource budgets, loadouts, and a server-vs-client comparison with a desync log.

A closer look

Design in a dedicated editor

Create a UCrimsonSkillTree asset and lay out nodes visually. Each Visual mirror renders a real instance of your node widget class through the same InitializeSkillNode call the game makes, so the preview is WYSIWYG by construction, and opening one never dirties the asset.

Drop in the runtime manager

Add UCrimsonSkillTreeManager to your Player State and it replicates with the player, surviving pawn respawns. It initializes itself on BeginPlay; your one job is filling Configured Skill Trees with the assets it owns.

  • Inject trees at runtime with AddDynamicSkillTree or a Game Feature action
  • Host actor implements ICrimsonSkillTreeInterface so the manager can resolve the pawn its effects belong to

Activate nodes from anywhere

Spend points and activate nodes from Blueprint or C++. The client calls the manager, the manager fires a validated server RPC, and the result replicates to every client.

  • Commit several changes as one all-or-nothing batch
  • Respec a whole tree into a new allocation in one step
  • Save and restore named loadouts

Nodes are your widgets, not ours

A node is any UUserWidget that implements ICrimsonSkillTreeNodeWidget: no base class to inherit and no registration step, so nodes can be built on your project's own CommonUI button and keep its focus, styling and input handling.

  • UCrimsonSkillTreeWidget_Node is a ready-made implementation if you'd rather subclass one
  • Nodes don't sit on a grid; UCrimsonSkillTreeNavigationLibrary answers "which node is up from here" for gamepad and keyboard

Technical details

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

Frequently asked questions

Do I need C++ to use it?
Mostly no: the manager, the host interface, tree assets, node actions, node widgets, hover handling and gamepad navigation are all Blueprint. One piece is not: the connection layer that paints the lines between nodes is driven from C++ (RebuildConnections, UpdateConnectionStates and UpdateZoomLOD take a widget map and a policy object that aren't Blueprint-exposed), so the widget hosting the graph needs a C++ parent class. Blueprint everything else on top of it.
Does it come with a skill tree screen?
It ships the parts, not the screen: node, decoration and tooltip widgets plus the connection layer that paints the lines, and a how-to that walks the host canvas which assembles them, a Canvas Panel of node widgets placed from the Visual graph's baked layout. A prebuilt screen and graph exist in CrimsonCore (navigation map, pan/zoom, gamepad prompts already wired), but CrimsonCore compiles only in a project that has every Crimson plugin installed, so it is an alternative to that page rather than a step in it.
Does it replicate in multiplayer?
Yes, the runtime is server-authoritative. Node state and resource allocations replicate as delta-only FastArrays, player actions early-return unless the owner has authority and reach the server through validated Server_ RPCs, and a rejected action sends a failure message back to the client through the manager's OnNodeFailureMessage delegate. The Dev Tools window compares the same tree on the server and a chosen client per node, so a desync is something you can see rather than guess at.
Is it tied to a specific save system?
No. It exposes plain save structs you can persist with any system; with CrimsonCore, a save component wires them into CrimsonSaveSystem for you. The plugin never calls GameplayStatics and owns no persistence itself. Bump the asset's Version to invalidate incompatible old saves.
Does it depend on other Crimson plugins?
No. It is fully standalone and uses only Epic's own plugins: GameplayAbilities, CommonUI, GameFeatures, ModularGameplay and EnhancedInput, plus SlateIM for the editor dev tools. The prebuilt skill tree screen and the CrimsonSaveSystem component live in CrimsonCore; standalone, host the node widgets on your own canvas and bind OnNodeFailureMessage for rejected actions.
Will my tree assets survive packaging?
They need one setting. Skill trees are reached through soft references and by-id lookups, which the cooker does not follow; a tree granted at runtime through AddDynamicSkillTree has nothing hard-referencing it at all. Point PrimaryAssetScanPaths (Project Settings → Crimson → Crimson Skill Tree → Asset Discovery) at the folders holding your trees and the plugin registers them with the Asset Manager as AlwaysCook; a log line on editor start reports how many paths it registered.

Ready to build your progression system?

Grab CrimsonSkillTree on Fab, then follow the Quick Start: a tree asset, a manager on your Player State, and a node activating end to end, replicated to clients.

Get it on FabRead the DocsTake the Course

Pricing

CrimsonSkillTree is sold on Fab under Epic’s two standard licenses. Both include the full plugin, source, and updates.

Personal$39.99For individuals & teams under $100K revenueGet it on Fab
Professional$69.99For companies over $100K revenueGet it on Fab

Completes your setup

Each Crimson plugin runs standalone, so add only what your game needs:

$39.99 / $79.99 ProCrimsonAbilitySystem

A full Gameplay Ability System layer for UE5.

  • Custom ASC & Abilities
  • Slot-Based Augments
  • Modifiers & Phases
  • Graph-Based Combos
FreeCrimsonSaveSystem

Fragment-based saving: each system owns its own data.

  • Independent Fragments
  • No Cross-Plugin Coupling
  • Blueprint-Ready
FreeCrimsonInput

Tag-driven Enhanced Input with GAS ability binding.

  • Ability Input Binding
  • Per-Player Rebinding
  • Settings Modifiers
  • Input Clash Analyzer