Domain-Based C++ Logging With Nova

Nova is a new C++ logging library that uses compile-time types for logging domains instead of runtime string identifiers or global severity levels, enabling independent per-subsystem configuration and routing. The library includes Flare, an async-signal-safe crash logging component that writes structured records to disk without heap allocation or locks. Benchmarks show Nova performs competitively across realistic workloads, particularly in scenarios requiring deterministic behavior and bounded memory usage.

Repository: https://github.com/kmac-13/nova/ Benchmarks: https://github.com/kmac-13/nova/blob/main/docs/BENCHMARKS.md I am pleased to announce the initial release of Nova - a modern C++ logging library focused on deterministic behavior, compile-time configurability, and flexible domain-based routing for systems ranging from hosted platforms down to bare-metal and safety-critical environments. There are already several quality C++ logging libraries available. However, most logging libraries organize routing and filtering around severity levels and rely on global logger configuration or runtime string-based logging categories. Engineers are often forced to encode subsystem behavior into a limited set of severity levels while also considering which thresholds will be enabled in production. This also leads to situations where enabling debug logging for one subsystem effectively requires enabling debug logging across unrelated areas of the application. Nova instead treats logging domains as compile-time types, allowing logging configuration and routing to directly reflect application structure rather than forcing subsystems into global severity categories. Domains can represent subsystems, modules, interfaces, classes, libraries, or any other domain-specific concept, and each domain can be independently enabled, disabled, or routed without reliance on shared global configuration. Because domains are independent types rather than shared string identifiers, libraries can define their own logging domains without interfering with application or third-party logging configuration. Additional goals of the library include: Nova also includes Flare, an async-signal-safe crash and forensic logging component that writes structured diagnostic records directly to disk from signal handlers - without heap allocation, locks, or non-signal-safe C++ runtime features. include <nova.h // define a domain can be any type struct MotionPlanner {}; // configure the domain with a name MOTION , enabled state true , and clock type steadyNanosecs NOVA LOGGER TRAITS MotionPlanner, MOTION, true, kmac::nova::TimestampHelper::steadyNanosecs ; int main { // configure motion planner sink as mpSink ... // bind the mpSink to the MotionPlanner logging domain kmac::nova::ScopedConfigurator config; config.bind< MotionPlanner &mpSink ; // log NOVA LOG MotionPlanner << "Planning trajectory..."; } Here we can see that the MotionPlanner domain is defined, the traits for the domain are configured, a target sink is bound to the domain, and logging is performed. In this example, the domain is a simple, empty struct, but a domain can be any type, including interface, abstract, or concrete classes. A domain can even be a specific class, and logging can be limited to the scope of that class. Using types as logging domains enables compile-time routing, strong subsystem separation, and per-domain configuration and enablement. Disabled domains can be eliminated entirely by the compiler, and type names prevent the silent runtime failures that string-based routing can introduce. Additionally, per-domain control means that enabling verbose logging for one subsystem has no effect on any other - there is no shared severity threshold to raise or lower across the entire application just to see detailed output from a single area. Nova has been benchmarked against several popular C++ logging libraries, including Quill and spdlog, using: The benchmarks intentionally normalize queue sizing and backend threading models to avoid structurally advantaging any particular library configuration. Results varied by workload, but several patterns consistently emerged: While Nova does not always achieve the highest theoretical front-end enqueue rate, it performed extremely competitively across a broad range of realistic workloads, especially where deterministic behavior and bounded memory usage are important. Full benchmark methodology and raw benchmark data are available in the repository. The initial release is now available at the repository linked above. I am still actively working on improving the library with additional features such as: I would appreciate feedback on any aspects of Nova e.g. integration experience, cross-platform/compiler issues, feature requests . If you try Nova in a project, I’d love to hear how it performs and where it can improve. Thanks for reading.