detailed output from a single area.

### Performance

Nova has been benchmarked against several popular C++ logging libraries, including Quill and spdlog, using:

* multiple thread counts
* fixed queue sizes
* sustained throughput scenarios
* guaranteed-delivery latency tests
* both real file sinks and counting sinks to isolate I/O overhead

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:

* Nova performed particularly well in guaranteed-delivery scenarios and bounded-memory configurations
* Nova's synchronized sink significantly outperformed comparable synchronous configurations from other libraries
* Nova's async backend (using a no-I/O counting sink) demonstrated competitive throughput across thread counts while maintaining zero per-record heap allocation throughout
* Quill achieved extremely high front-end enqueue throughput, but with substantial drop rates under sustained overload conditions
* spdlog async showed performance degradation under heavy multi-threaded workloads

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.

### Design Philosophy

| Principle | Description |
|---|---|
| Domain-based routing | Logging should reflect application structure rather than forcing subsystems into global severity categories |
| Deterministic behavior | No heap allocation, exceptions, or RTTI by design - heap usage is explicitly documented where it exists (such as in a small number of convenience sinks) and avoided everywhere else across Nova core, Nova Extras, and Flare |
| Explicit tradeoffs | Buffer and queue sizes, synchronous vs asynchronous delivery, blocking, and fan-out behavior should be visible and configurable |
| Compile-time configuration | Logging configuration should be resolved at compile time whenever practical |
| Production-oriented design | Optimize for sustained, realistic workloads and operational predictability |
| Modern C++ | Use modern language features without introducing unnecessary complexity or heavy dependencies |
| Performance-conscious design | Logging overhead should remain predictable and low, especially in latency-sensitive and multi-threaded systems |

### Current Status & Feedback

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:

* additional sinks/backends
* packaging and integration polish
* binary logging

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.

https://redd.it/1tm0ihy
@r_cpp