Code Quality Rank: L4
Programming language: C++
License: GNU General Public License v3.0 or later
Tags: Logging    
Latest version: v3.0.2

reckless alternatives and similar libraries

Based on the "Logging" category.
Alternatively, view reckless alternatives based on common mentions on social networks and blogs.

  • spdlog

    Fast C++ logging library.
  • glog

    C++ implementation of the Google logging module
  • Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
    Promo www.influxdata.com
    InfluxDB Logo
  • Easylogging++

    C++ logging library. It is extremely powerful, extendable, light-weight, fast performing, thread and type safe and consists of many built-in features. It provides ability to write logs in your own customized format. It also provide support for logging your classes, third-party libraries, STL and third-party containers etc.
  • easyloggingpp

    C++ logging library. It is extremely powerful, extendable, light-weight, fast performing, thread and type safe and consists of many built-in features. It provides ability to write logs in your own customized format. It also provide support for logging your classes, third-party libraries, STL and third-party containers etc.
  • plog

    Portable, simple and extensible C++ logging library
  • log4cplus

    log4cplus is a simple to use C++ logging API providing thread-safe, flexible, and arbitrarily granular control over log management and configuration. It is modelled after the Java log4j API.
  • loguru

    A lightweight C++ logging library
  • G3log

    G3log is an asynchronous, "crash safe", logger that is easy to use with default logging sinks or you can add your own. G3log is made with plain C++14 (C++11 support up to release 1.3.2) with no external libraries (except gtest used for unit tests). G3log is made to be cross-platform, currently running on OSX, Windows and several Linux distros. See Readme below for details of usage.
  • quill

    Asynchronous Low Latency C++ Logging Library
  • Boost.Log

    Boost Logging library
  • Blackhole

    Yet another logging library.
  • mini-async-log

    Non bloated asynchronous logger
  • lwlog

    Very fast synchronous and asynchronous C++17 logging library
  • Description

    Mini async log C port. Now with C++ wrappers.
  • logog

    logog is a portable C++ library to facilitate logging of real-time events in performance-oriented applications, such as games. It is especially appropriate for projects that have constrained memory and constrained CPU requirements.
  • uberlog

    Cross platform multi-process C++ logging system
  • xtr

    A Fast and Convenient C++ Logging Library for Low-latency or Real-time Environments
  • Serenity Logger

    Yet another Fast and Efficient logging framework. The goal is to be nanosecond level fast with extensibility (inspired by loggers such as spdlog, nanolog, and fmtlog and heavily influenced by the formatting used in fmtlib and <format>). This uses a built-in formatter that can be swapped out for <format> or fmtlib if desired.
  • templog

    A very small and lightweight C++ library which you can use to add logging to your C++ applications. [Boost]
  • Log4cpp

    A library of C++ classes for flexible logging to files, syslog, IDSA and other destinations. [LGPL]

Do you think we are missing an alternative of reckless or a related project?

Add another 'Logging' Library


[[Performance chart for a quad-core CPU](doc/images/performance_mandelbrot_difference.png)](doc/performance.md)


Reckless is an [extremely low-latency, high-throughput logging library](doc/performance.md). It was created because I needed to perform extensive diagnostic logging without worrying about performance. Other logging libraries boast the ability to throw log messages away very quickly. Reckless boasts the ability to keep them all, without worrying about the performance impact. Filtering can and should wait until you want to read the log, or need to clean up disk space.

How it works

By low latency I mean that the time from calling the library and returning to the caller is as short as I could make it. The code generated at the call site consists only of pushing the arguments on a shared, lockless queue. In the non-contended case this has roughly the same cost as a making a function call. The actual message formatting and writing is performed asynchronously by a separate thread. This removes or hides several costs:

  • No transition to the kernel at the call site. The kernel is an easily overlooked but important cost, not only because the transition costs time, but because it pollutes the CPU cache. In other words, avoiding this makes your non-logging code run faster than if you were using a library that has to enter the kernel to perform its work.
  • No locks need to be taken for synchronization between threads (unless the queue fills up; see the performance article for more information about the implications of this).
  • No text formatting needs to be performed before resuming the main task of the program.
  • It doesn't have to wait for the actual I/O operation to complete.
  • If there are bursts of log calls, multiple items on the queue can be batched into a single I/O operation, improving throughput without sacrificing write latency.

For a more detailed performance discussion and statistics, see the [performance article](doc/performance.md).

What's the catch?

As all string formatting and I/O is done asynchronously and in a single thread, there are a few caveats you need to be aware of:

  • If you choose to pass log arguments by reference or pointer, then you must ensure that the referenced data remains valid at least until the log has been flushed or closed (unless you're only interested in logging the value of the pointer itself). The best option for dynamically allocated data is typically std::string, std::shared_ptr or std::unique_ptr.
  • You must take special care to handle crashes if you want to make sure that all log data prior to the crash is saved. This is not unique to asynchronous logging—for example fprintf will buffer data until you flush it—but asynchronous logging arguably makes the issue worse. The library provides convenience functions to aid with this.
  • As all string formatting is done in a single thread, it could theoretically limit the scalability of your application if formatting is expensive or your program generates a high volume of log entries in parallel.
  • Performance becomes somewhat less predictable and harder to measure. Rather than putting the cost of the logging on the thread that calls the logging library, the OS may suspend some other thread to make room for the logging thread to run.

Basic use

#include <reckless/severity_log.hpp>
#include <reckless/file_writer.hpp>

// It is possible to build custom loggers for various ways of formatting the
// log. The severity log is a stock policy-based logger that allows you to
// configure fields that should be put on each line, including a severity
// marker for debug/info/warning/error.
using log_t = reckless::severity_log<
    reckless::indent<4>,       // 4 spaces of indent
    ' ',                       // Field separator
    reckless::severity_field,  // Show severity marker (D/I/W/E) first
    reckless::timestamp_field  // Then timestamp field

reckless::file_writer writer("log.txt");
log_t g_log(&writer);

int main()
    std::string s("Hello World!");

    // You can use ordinary printf-style syntax, but unlike stdio this
    // is type-safe and extensible.
    g_log.debug("Pointer: %p", s.c_str());
    g_log.info("Info line: %s", s);

    for(int i=0; i!=4; ++i) {
        reckless::scoped_indent indent;  // The indent object causes the lines
        g_log.warn("Warning: %d", i);    // within this scope to be indented.

    g_log.error("Error: %f", 3.14);

    return 0;

This would give the following output:

D 2019-03-09 12:53:54.280 Pointer: 0x7fff58378850
I 2019-03-09 12:53:54.280 Info line: Hello World!
W 2019-03-09 12:53:54.280     Warning: 0
W 2019-03-09 12:53:54.280     Warning: 1
W 2019-03-09 12:53:54.280     Warning: 2
W 2019-03-09 12:53:54.280     Warning: 3
E 2019-03-09 12:53:54.280 Error: 3.140000


The library works on Windows and Linux. BSD is on the roadmap. I don't own any Apple computers, so OS X won't happen unless someone sends me a patch or buys me hardware.


Alternative 1: Using Visual Studio

On Windows it is recommended to use Visual Studio for building the library. Simply open reckless.sln, choose "batch build" and "select all". Then press Build. The library files will be placed in the build subdirectory.

To build a program against the library you need to set your library path to point to the appropriate library build for your configuration, and set the include path to $(RECKLESS)/reckless/include, where RECKLESS, given that RECKLESS is a property that points to the reckless source directory.

Alternative 2: using Make

To build the library using GNU Make, clone the git repository and run make. This only works with GCC-compatible compilers.

To build a program against the library, given the variable RECKLESS pointing to the reckless root directory, use e.g.:

g++ -std=c++11 myprogram.cpp -I$(RECKLESS)/reckless/include -L$(RECKLESS)/reckless/lib -lreckless -lpthread

Alternative 3: using CMake

To build the library using CMake, clone the git repository and run the following commands:

mkdir build; cd build
cmake ..

To build a program against this library using CMake, add the following line to your program's CMakeLists.txt:


Subsequently, to link this library to a program (e.g. your_executable), add the following to your program's CMakeLists.txt:

target_link_libraries(your_executable reckless pthread)

More information

For more details, see the [manual](doc/manual.md).


Other logging libraries with similar, asynchronous design are