Axom Core: Subsystem Logic Orchestration & Deterministic Chronological Engine

A premium native C++ runtime framework for centralising background gameplay systems, scalable chronological simulation, and automated logic object execution without scattered timers, frame-rate ticks, or fragile manager Blueprints.

Developed by Axom Studios, Axom Core is an upcoming, highly optimized performance template designed exclusively for Unreal Engine developers and interactive software creators.

Product Summary

Axom Core is a modular runtime orchestration framework for Unreal Engine 5. It decouples complex background gameplay systems from visual actors and level scripts, centralising them into native C++ runtime systems that remain fully accessible through clean Blueprint workflows. Built for developers working on systemic, simulation-heavy, or persistent-world projects, Axom Core replaces fragile manager actors, scattered timer loops, and heavy actor Tick usage with a unified temporal architecture. By using self-contained Axom Logic Objects alongside configurable runtime registration, developers can build modular background features such as economy loops, AI schedules, quest timelines, world events, and environment cycles that initialise automatically and run from a central simulation clock.

INTRODUCTORY LAUNCH OFFER

To celebrate the upcoming release of Axom Core, the framework will be available at a limited-time introductory price:

• Personal / Indie License: £65 (Standard MSRP: £85)
• Studio / Professional License: £295 (Standard MSRP: £345) Secure your project's architectural foundation on release and receive all future Core updates for life!

(Coming Soon)

Interactive Testing & Video Proof

Watch the 90-Second Walkthrough: See Axom Core Time Scale Dilation & Node

 Workflows Download the Compiled Demo: Axom Core Diagnostic Sandbox Project on GitHub Run the built-in stress-test utility to fire 10,000 simultaneous pulses and verify the native 0.0ms CPU thread load using the Unreal Insights profiler before you buy.

*Marketplace Note: Upon commercial release, Axom Core will be accessible globally via the Fab Web Storefront and natively integrated directly inside the Epic Games Launcher under the Unreal Engine environment.*

(Links Coming Soon with the Demo)

The Axom Runtime Architecture

Unlike typical marketplace time assets that place logic inside a single manager actor or monolithic Blueprint, Axom Core separates lifecycle, time, scheduling, configuration, and logic execution into clear native C++ runtime layers.

Core Runtime Layers

1. Runtime Subsystem

   Coordinates framework lifecycle, config loading, auto-discovery, and Logic Object registration.

2. Time Subsystem

   Owns simulation time, time scale, calendar state, interval broadcasts, leap-year validation, and date/time setters.

3. Event Scheduler Subsystem

   Stores and resolves one-time scheduled tasks tied to simulation seconds, minutes, hours, days, months, and years.

4. World Subsystem

   Provides the central systemic pulse and drives the native time loop through a fixed 0.1-second runtime interval.

5. Runtime Config System

   Supports explicit Logic Object registration for controlled production pipelines.

6. Auto-Discovery Pipeline

   Optionally scans configured content paths for Axom Logic Object Blueprints and registers them automatically at startup.

7. Project Settings Integration

   Exposes framework setup options directly inside Unreal Engine Project Settings, including runtime config selection and auto-discovery paths.

Core Features

• Native C++ Runtime Backbone

  Core time accumulation, interval processing, scheduler resolution, and object registration are handled in C++ while remaining Blueprint-accessible.

• Blueprint Logic Objects

  Build background systems as modular Blueprint logic objects instead of fragile level actors or Blueprint subsystem subclasses.

• Central Simulation Clock

  Drive seconds, minutes, hours, days, weeks, months, and years from one authoritative time system.

• Runtime Time Scale Control

  Change Axom simulation speed through Blueprint-safe C++ wrapper nodes.

• Calendar-Aware Date Logic

  Supports days-per-month configuration, month normalization, and leap-year validation.

• One-Time Scheduled Tasks

  Schedule delayed events by seconds, minutes, hours, days, months, or years, then receive callbacks directly inside the same Axom Logic Object.

• Task ID Routing

  Use named Task IDs with Switch on Name to route multiple scheduled behaviours through one clean Blueprint event.

• Task Cancellation and Querying

  Cancel, clear, or check scheduled tasks at runtime.

• Dual Registration Modes

  Use auto-discovery for rapid prototyping or manual config registration for strict production control.

• No Required Manager Actors

  Axom Core does not require developers to place manager actors into every level.

• No Blueprint Subsystem Subclasses

  Keeps subsystem authority native and avoids duplicate subsystem instance problems.

What This Product Solves

The Manager Actor Trap

Axom Core removes the need to place fragile manager actors into levels. Background systems can exist as registered runtime logic objects instead of scene-dependent actors.

Tick and Delay Sprawl

Instead of spreading Tick events, Delay nodes, and timer handles across unrelated Blueprints, Axom provides central interval events and scheduled task callbacks.

Chronological Drift and Fragmentation

By routing simulation time through one authoritative C++ time subsystem, background systems can share consistent chronological context.

Architectural Coupling

Logic Objects allow background systems to remain modular and decoupled. Economy logic, AI schedules, world events, faction updates, and environment cycles can each live in their own isolated Blueprint module.

UObject Blueprint Subsystem Friction

Axom avoids Blueprint subclassed subsystems as a core pattern. Native C++ subsystems own authority; Blueprints provide behaviour through Logic Objects.

Basic Workflow

1. Enable the Axom Core plugin.
2. Configure Axom Core in Unreal Project Settings.
3. Choose auto-discovery or manual config registration.
4. Create a Blueprint child of the Axom Logic Object base class.
5. Add logic using events such as:
   • On Logic Ready
   • On Second Interval
   • On Minute Interval
   • On Hour Interval
   • On Day Interval
   • On Week Interval
   • On Month Interval
   • On Year Interval
   • On Scheduled Task Triggered
6. Press Play. Axom registers the Logic Object and drives it through the central runtime systems.

Ideal For

• Sandbox RPGs with persistent world states.
• Colony management and survival games.
• Strategy games with background systems.
• AI schedule systems.
• Economy and trade simulations.
• Quest timelines and delayed consequence systems.
• Calendar-driven world events.
• Simulation-heavy Blueprint projects that need cleaner architecture.

Example Uses

• Schedule a bandit raid after 3 in-game days.
• Run economy recalculation once per day.
• Trigger NPC routines every in-game hour.
• Change world behaviour based on time scale.
• Route multiple delayed events through Task IDs.
• Advance seasonal or monthly simulation logic.
• Cancel pending events when player intervention changes the world state.

FAQ

How is Axom Core optimized for larger projects?

Axom Core avoids per-actor Tick sprawl by centralising runtime time progression and interval broadcasting natively in C++. Auto-discovery is performance-isolated, running strictly during startup/initialization rather than during active gameplay to eliminate runtime disk reads or loading spikes. The public sandbox demo project includes an active stress-test dashboard capable of executing 10,000 overlapping chronological events simultaneously with near-zero frame-time footprint on the game thread.

Can I disable automatic folder scanning?

Yes. Auto-discovery can be disabled. Teams can instead use manual config registration to explicitly define which Axom Logic Objects should load.

Does this replace Unreal Engine's native FTimerManager?

No. Local gameplay tasks such as weapon reloads, UI flashes, or short actor-specific effects should still use Unreal's normal timers where appropriate. Axom Core is intended for higher-level background systems that need shared simulation time, interval events, calendar logic, and modular orchestration.

Can this plugin be used in Blueprint-only projects?

Yes. Axom Core is built in C++, but its workflow is exposed through Blueprint Logic Objects, Blueprint events, and Blueprint-callable wrapper nodes.

Is this multiplayer-ready?

Axom Core is currently best understood as a runtime orchestration framework for single-player or server-authoritative simulation architectures. Multiplayer projects should treat Axom time authority as a server-side/system-authoritative layer and validate replication strategy according to their own network model.

Axom Core is a local runtime orchestration framework optimized for single-player games or the server-authoritative layer of multiplayer simulation architectures. Networked projects should instantiate Axom Core strictly on the server as a master clock and event coordinator, using standard RPCs or replicated state variables to broadcast visual calendar updates down to clients.

Project Lifecycle Note: Active development timeline and codebase shift formalized on 05/11/2026.