A low-latency, high-throughput asynchronous logging library for C++ that minimizes performance impact on application threads.
Reckless is an asynchronous logging library for C++ that provides extremely low-latency, high-throughput logging by offloading formatting and I/O operations to a background thread. It solves the performance problem of diagnostic logging in performance-critical applications by minimizing the time spent in logging calls, allowing developers to keep all log messages without worrying about performance impact.
C++ developers building performance-critical applications that require extensive diagnostic logging, such as real-time systems, high-frequency trading platforms, or game engines where logging overhead must be minimized.
Developers choose Reckless over alternatives because it offers near-zero latency at the call site through its lockless queue design, avoids kernel transitions that pollute CPU caches, and maintains type safety while providing printf-style formatting—all while keeping all log messages rather than discarding them for performance reasons.
Reckless logging. Low-latency, high-throughput, asynchronous logging library for C++.
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Uses a shared lockless queue to avoid synchronization overhead in non-contended cases, minimizing call-site latency as described in the 'How it works' section.
Offloads formatting and I/O to a background thread, eliminating kernel transitions and I/O wait times from the calling thread to improve overall performance.
Provides printf-style syntax with type safety and extensibility, demonstrated in the basic use example with debug and info calls, unlike standard stdio.
Batches multiple log entries into single I/O operations during bursts, enhancing throughput without increasing write latency, as noted in the performance features.
When logging references or pointers, data must remain valid until the log is flushed, adding risk and requiring careful management with std::string or smart pointers.
Asynchronous logging can buffer data, making it harder to ensure all logs are saved before a crash, necessitating special handling as mentioned in the 'What's the catch?' section.
All formatting occurs in one background thread, potentially limiting scalability for applications with high parallel log volume, a caveat acknowledged in the README.
Only natively supports Windows and Linux, with no plans for macOS or BSD unless community contributions are provided, restricting cross-platform use.