Table of Contents

LuciferCore.Platforms v2.x Release Notes

Changelog and upgrade guide for the LuciferCore.Platforms application runtime across all v2.x versions.

v2.13.0

Release Date: October 2026 | Target: .NET 9.0 | Status: Latest

Version 2.13.0 introduces selective dynamic configuration hot-reloading via ConfigAttribute.Sync and integrates LuciferConfig directly with FileCache for realtime .lucifercore file tracking.

Key Features & Architectural Changes

  • Selective Dynamic Config Sync (ConfigAttribute.Sync):

    • Added public bool Sync { get; init; } = false; to [ConfigAttribute].

    • 100% Backward Compatible: Default is false (loaded once at startup), preventing unexpected runtime mutations on critical infrastructure properties.

    • When Sync = true, configuration properties automatically receive live updates whenever the .lucifercore file changes at runtime.

  • FileCache-Driven Configuration Tracking:

    • Replaced manual file existence checks and ad-hoc relative paths with FileCache.InsertPath(".", filter: ".lucifercore", handler: ...).

    • Relies entirely on FileCache.BaseDirectory for single-root resolution across dev (bin/../../..), testing, and production environments.

    • Standardized exclusively on reading .lucifercore at project root, removing deprecated assets/config/.lucifercore scanning.

    • Leverages FileCache.InsertHandler to intercept file change events, parse updated key-value pairs into Environment, and selectively update only properties marked with Sync = true.

v2.12.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.12.0 synchronizes the application runtime and dependency references with LuciferCore v6.19.0.

v2.11.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.11.0 synchronizes the runtime engine and dependency references with LuciferCore v6.18.0.

v2.10.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.10.0 updates runtime orchestration with intelligent FileCache path resolution.

v2.9.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.9.0 delivers adaptive CPU idle backoff in SimulationManager, eliminating 100% CPU thread starvation during timer deferrals while maintaining immediate zero-latency execution.

Key Features & Architectural Changes

  • Adaptive Idle CPU Backoff in SimulationManager:

    • SimulationManager.Update() monitors consecutive idle ticks (_idleTicksStreak) returned by _wheel.Tick().

    • When workload > 0 but a complete rotation of the wheel (WheelSize = 512 ticks) executes without any event reaching its monotonic real-time deadline (all pending events are awaiting future real-time timestamps), the thread yields via WaitForWork(1).

    • Reduces idle CPU utilization from 100% to 0% during waiting intervals while running completely unthrottled with 0 delay whenever events are actively due.

  • Zero-Latency Scheduling Wakeup:

    • SimulationManager.Schedule<T>(tick) proactively triggers NotifyWork() when tick <= 1.

    • If the worker thread is currently sleeping in WaitForWork(1), it is signaled and wakes up immediately (0ms latency).

  • Safe Precondition Guard on Pooled Time Events:

    • Hardened TimeEvent.Precondition() to check TargetTimestamp > 0 && Time.time >= TargetTimestamp.

    • Guarantees that freshly popped events from EventPool<T> (where TargetTimestamp == 0) are never prematurely executed or retired before caller property initialization.

  • Extensible Worker Wait Hook in ManagerBase:

    • Added protected bool WaitForWork(int millisecondsTimeout) to ManagerBase.

    • Exposes safe timeout-based synchronization against _wakeEvent for derived manager threads without breaking encapsulation.

v2.8.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.8.0 centralizes simulation timers exclusively into Time.cs and removes forwarding wrappers from the primary facade, establishing a cleaner and more focused microkernel architecture.

Key Features & Architectural Changes

  • Zero-Facade Timer Dispatching:

    • Removed SetTimeout and SetInterval forwarding methods from Lucifer.cs.

    • Kept Lucifer.cs focused purely on low-level core simulation management (Schedule<T>, Reschedule<T>, RescheduleNextCycle<T>).

  • Centralized Timer API in Time.cs:

    • Time.SetTimeout and Time.SetInterval directly instantiate and configure TimeoutEvent and TimeIntervalEvent instances without intermediate layers.

    • Fully unified with multi-instance generic manager partitioning (ManagerBase<SimulationManager>.Resolve(key)).

v2.7.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.7.0 delivers a clean, minimalist time and simulation event architecture, providing dedicated one-shot (TimeoutEvent) and recurring (TimeIntervalEvent) models fully integrated with the hierarchical timing wheel and Event<T>.OnExecute.

Key Features & Architectural Changes

  • Clear Time Architecture (TimeEvent<T>, TimeoutEvent<T>, TimeIntervalEvent<T>):

    • Established TimeEvent<T> as the pure abstract base class solely responsible for monotonic real-time thresholds (TargetTimestamp = Time.time + delayMs) and wheel cycle deferrals (Precondition() => Time.time >= TargetTimestamp).

    • Added TimeoutEvent<T> (and non-generic TimeoutEvent) for one-shot delayed simulation executions with direct TimeoutMs property assignment and automatic recycling.

    • Added TimeIntervalEvent<T> (and non-generic TimeIntervalEvent) for recurring simulation loops with in-place rescheduling, direct IntervalMs property assignment, and loop lifecycle controlled via IsRunning.

    • Fully unified with Event<T>.OnExecute without intermediate wrapper actions, delegate fields, or helper classes.

    • Exposed high-level helpers Time.SetTimeout and Time.SetInterval returning TimeoutEvent and TimeIntervalEvent.

    • Exception isolation within TimeIntervalEvent.ExecuteEvent ensuring unhandled exceptions in business logic never cause recurring loops to die silently.

v2.6.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.6.0 introduces a major architectural decoupling of the application runtime, establishing a zero-facade design with self-contained manager/server lifecycles, multi-instance generic partitioning, and dedicated command handling.

Key Features & Architectural Changes

  • Decoupled Architecture & Zero-Facade Runtime:

    • Completely eliminated monolithic manager/server dictionaries (s_registeredManagers, s_registeredServers) and command forwarding wrappers from Lucifer.cs.

    • Managers and servers now self-manage their lifecycles, registries, and administrative console commands.

    • Lucifer.cs only retains high-level composite lifecycle commands (/start all, /stop all, /restart all, sa, xa, ra).

  • Multi-Instance Generic Manager Partitioning (ManagerBase<T>):

    • Introduced the generic base class ManagerBase<T> : ManagerBase where T : ManagerBase<T> utilizing the Curiously Recurring Template Pattern (CRTP).

    • Automatically registers instances on instantiation into a lock-free copy-on-write typed array s_instances.

    • Provides ultra-fast \(O(1)\) modulo-based deterministic routing via ManagerBase<T>.Resolve(long key = 0).

    • Enables developers to instantiate unlimited isolated manager instances (e.g. new SimulationManager(256)) mapped to game zones, rooms, or partition keys.

  • Dedicated ServerManager:

    • Created ServerManager inheriting from ManagerBase with [Manager("ServerManager", Order = -2)].

    • Exclusively owns and handles all server lifecycle console commands:

      • Individual: /start server, start server, start -s, /stop server, stop server, stop -s, /restart server, restart server, restart -s.

      • Batch: /start servers, start servers, start -as, ss, /stop servers, stop servers, stop -as, xs, /restart servers, restart servers, restart -as, rs.

  • Manager-Owned Administrative Commands:

    • ManagerBase now directly hosts all manager administration commands:

      • Individual: /start manager, start manager, start -m, /stop manager, stop manager, stop -m, /restart manager, restart manager, restart -m.

      • Batch: /start managers, start managers, start -am, sm, /stop managers, stop managers, stop -am, xm, /restart managers, restart managers, restart -am, rm.

  • Direct TimeEvent<T> Rescheduling:

    • Updated TimeEvent<T> to defer cycles directly to its owning simulation manager via ManagerBase<SimulationManager>.Resolve(Index).RescheduleNextCycle((T)this).

    • Eliminates cross-instance state pollution, race conditions, and accidental thread transfers when running multiple simulation wheels.

  • Instance-Specific Worker Thread Identification:

    • Worker threads spawned by ManagerBase are automatically labeled as ${GetType().Name}#${InstanceIndex} (e.g., SimulationManager#0, SimulationManager#1).

    • Simplifies thread profiling, APM metrics, and post-mortem debugging.

v2.5.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.5.0 aligns the platform application runtime with the new on-demand asset pipeline introduced in LuciferCore v6.13.0, enhancing hot-reload workflows during development and optimizing memory usage in production.

Key Features & Enhancements

  • On-Demand Static Content & Lazy Asset Pipeline:

    • Server static asset management (AddStaticContent) now leverages FileCache lazy loading by default.

    • Web and WebSocket servers (such as WssServer and HttpsServer) start up instantaneously, deferring disk I/O until files are first accessed by clients.

    • Idle static assets are automatically swept from memory via background sliding expiration.

  • Cascading Fallback Directory Resolution:

    • Asset and configuration loaders automatically search parent project source trees (../../..) in development mode before falling back to the local runtime directory (bin).

    • Enables instant hot reloading of client web pages, templates, and certificates during live development without requiring manual file copying to the build output directory.

  • Safe Cache Freezing:

    • Server constructors calling Cache.Freeze() now safely operate in lazy mode without corrupting the dynamic file loader.

v2.4.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.4.0 optimizes background worker pools and simulation loops by taking advantage of LuciferCore's zero-allocation spatial and sampling algorithms.

Performance & Worker Pools

  • ManagerWorkerPool Enhancements:

    • Streamlined multi-threaded worker pools for parallel manager execution.

    • Integrated zero-allocation SubsetSampler routines for batch item distribution and player matchmaking pools.

  • Entity Partitioning in Simulation:

    • SimulationManager workloads can now natively integrate with SpatialGrid for contiguous, zero-allocation 2D spatial queries (AOE radius checks, proximity detection) across game worlds.

  • Package Synchronization:

    • Aligned core package references to LuciferCore v6.12.0.

v2.3.0

Release Date: October 2026 | Target: .NET 9.0

Version 2.3.0 refines high-resolution timer scheduling, cycle rescheduling mechanics, and the CRTP-based event pool.

Enhancements

  • Next-Cycle Deferral Helpers:

    • Added Lucifer.RescheduleNextCycle() and SimulationManager.RescheduleNextCycle() to defer recurring work to the subsequent timing wheel tick cleanly.

    • Avoids infinite loops when an event needs to re-queue itself immediately during execution.

  • Safe Event Pool Management:

    • Enhanced TimeEvent<T> (Curiously Recurring Template Pattern) lifecycle logic.

    • Fixed edge cases where rescheduled events could be prematurely recycled back into ObjectPool<T> while still referenced in the scheduler.

  • High-Resolution Timer Integration:

    • Extended Time.cs with convenient utility methods for deadlines, timeouts, intervals, and monotonic delta calculations.

v2.2.0

Release Date: September 2026 | Target: .NET 9.0

Version 2.2.0 introduces interactive diagnostic capabilities, command-line management, and asynchronous logging subsystems.

Interactive Management & Logging

  • Interactive CLI (LuciferCMD):

    • Built-in console loop supporting runtime operations: /start servers, /stop managers, /help, and custom user commands.

    • Commands are discovered declaratively via the [ConsoleCommand] attribute.

    • Integrated Fuzzy string matching to suggest closest valid commands upon typing mistakes.

  • Asynchronous High-Throughput LogManager:

    • Implemented non-blocking background logging with ConsoleLogger and rolling FileLogger.

    • Log lines format directly into raw UTF-8 spans, eliminating string allocations on high-frequency log paths.

v2.1.0

Release Date: September 2026 | Target: .NET 9.0

Version 2.1.0 delivers robust discrete simulation orchestration and integrates LuciferCore's hierarchical timing structures.

Simulation Engine & Timers

  • SimulationManager Lifecycle:

    • Introduced discrete event loop manager managing simulation ticks, fixed-timestep delta updates, and frame pacing.

    • Seamlessly drives the hierarchical TimingWheel and priority HeapQueue for millions of active game timers.

  • Declarative Manager Lifecycle:

    • Standardized start, tick, and shutdown sequences across all services extending ManagerBase and decorated with [Manager].

v2.0.0

Release Date: September 2026 | Target: .NET 9.0

Major Architecture Milestone

Version 2.0.0 is a milestone release that decouples application-level abstractions and runtime orchestration from the microkernel, establishing LuciferCore.Platforms as the dedicated runtime layer for modulith and microservice architectures.

Key Features

  • Compile-Time Route Source Generation:

    • Implemented Roslyn Source Generator (HandlerGenerator, MasterCodeGenerator) targeting .NET 9.0.

    • Eliminates reflection from the request-dispatch hot path by compiling route tables at build time for classes tagged with [Route] and [Handler].

    • Anchored using [StoreRoute] partial classes for zero-overhead method dispatching.

  • Monotonic Millisecond Time System:

    • Completely overhauled Time utility from floating-point seconds (double) to monotonic 64-bit millisecond integers (long).

    • Centralized Time.time, Time.Now, Time.Date, and scheduling helpers (SetTimeout, SetInterval).

    • Removed obsolete legacy timing wrappers from the Lucifer facade.

  • Reusable TimeEvent<T> (CRTP Pattern):

    • Introduced TimeEvent<T> base class for pooled, allocation-free timer events with built-in auto-rescheduling support.

  • Production-Ready Middleware Suite:

    • FirewallMiddleware: High-throughput IP blacklisting, connection throttling, and CIDR subnet filtering.

    • RateLimitMiddleware: Sliding-window rate limiter tracking client requests using monotonic timestamps.

    • SessionMiddleware: Lock-free session tracking with sliding expiration and automated cleanup.

  • Attribute-Driven Declarative Architecture:

    • Pure convention-based configuration without mandatory base classes:

      • [Server]: Declares network server endpoints and transport binding.

      • [Handler]: Marks classes containing dispatchable action methods.

      • [Manager]: Registers long-running background tasks and simulation workers.

      • [Service] & [Singleton]: Declarative dependency injection registration.

      • [Config]: Binds environment variables and configuration files to static properties.

      • [Bootstrap]: Designates startup initialization hooks.

Edit this page