Ultra-Light, High-Performance Asynchronous Logger

femtolog is a blazing-fast, minimal-overhead asynchronous logging library built for performance-critical applications. It leverages zero-cost abstractions, cache-aligned SPSC queues, and compile-time format string serialization.

Designed for modern C++ projects where every nanosecond counts.

• ☄ Overview
• 📖 Table of Contents
• 🚀 Features
• 📦 Usage
• 🔄 Workflow
• 📊 Benchmarks
  • System Environment
    • Literal without format
    • Format integer
    • Format multi integers
    • Format string
    • Format string view
    • Format mixed
    • Format large string
• 🔧 Installation
  • Using CMake
• 🔌 Custom Sinks
  • ✨ Implement Your Own Sink
• 🪪 License
• ❤️ Credits

• 🔧 Compile-time format string registration
• 🧵 True asynchronous logging pipeline
• 🎯 Zero dynamic memory allocations on the frontend
• 💾 Dedicated backend worker thread for formatting and output
• ⚡ Faster than spdlog, and quill in benchmark

femtolog supports formatting messages using fmtlib.

#include "femtolog/femtolog.h"

int main() {
  // get thread local logger instance
  femtolog::Logger logger = femtolog::Logger::logger();

  // initialize logger and register log sink
  logger.init();
  logger.register_sink<femtolog::StdoutSink<>>();
  logger.register_sink<femtolog::FileSink<>>("");
  logger.level("trace");

  // start the backend worker that dequeues logged entries
  logger.start_worker();

  std::string username = "pugur";
  float cpu_usage = 42.57;
  bool result = true;
  int error_code = -1;

  // log messages with compile-time interpreted format strings:
  logger.trace<"Hello {}\n">("World");
  logger.debug<"Hello World wo formatting\n">();
  logger.info<"User \"{}\" logged in.\n">(username);
  logger.warn<"CPU usage is high: {}%\n">(cpu_usage);
  logger.error<"Return value is: {}\n">(result);

  logger.fatal<"Fatal error occured; error code: {}\n">(error_code);

  logger.stop_worker();
  logger.clear_sinks();

  return 0;
}

The logging pipeline consists of a frontend (thread-local logger) and a backend (worker thread):

Format string literals ("...") are hashed at compile time into a format_id. Arguments are serialized as a raw byte stream and passed asynchronously from the frontend to the backend through an SPSC queue.

graph TD
    A[Logger - frontend] -->|embed format id by hash at compile time, serialize format args at runtime| B[SPSC Queue]
    B --> C[Backend Worker - async]
    C --> D[Deserialize and Format]
    D --> E[Sink: stdout / files / custom]

This architecture separates formatting from the hot path of logging, minimizing latency.

• OS: Ubuntu 22.04 x86_64
• CPU: Intel Core i3 12100 @ 4.3GHz
• RAM: DDR4 3600MHz 64GB

The following benchmark results were measured using Google Benchmark with Clang-21 -O3 Release build on the above environment. For comparison, results of similar logging benchmarks using the following libraries are also shown:

• quill
• spdlog

The benchmark codes are available in //src/bench/ directory and the detail results of benchmark are archived in //src/bench/results/archive directory. Benchmarks are generated in the //out/build/<platform>/<arch>/bin directory by setting FEMTOLOG_BUILD_BENCHMARK to true when building with CMake. After building, you can run the built benchmarks and collect results by executing //src/build/scripts/run_bench.py with the --format option. The results will be saved in the //src/bench/results/ directory in both json and png formats.

Add this repository as a git submodule:

git submodule add https://github.com/pugur523/femtolog.git ./femtolog --recursive

Add femtolog as a subdirectory:

add_subdirectory(femtolog)

target_link_libraries(your_target PRIVATE femtolog)

To install the compiled library:

set(INSTALL_FEMTOLOG TRUE)
set(FEMTOLOG_INSTALL_HEADERS TRUE)
add_subdirectory(femtolog)

target_link_libraries(your_target PRIVATE femtolog)

Need to log to a database, a network socket, or a ring buffer?

femtolog supports plug-and-play custom sinks via a simple interface:

To define a custom sink, just inherit from SinkBase and implement on_log():

#include "femtolog/sinks/sink_base.h"

class MySink : public femtolog::SinkBase {
 public:
  void on_log(const LogEntry& entry, const char* content, std::size_t len) override {
    // Write to file, send over network, etc.
    std::fwrite(content, 1, len, stderr);
  }
};

Then register your sink with the logger:

logger.register_sink<MySink>();

That's it — your sink will now receive fully formatted log entries, asynchronously, from the backend.

femtolog is licensed under the Apache 2.0 License.

• zlib
  Used in FileSink and JsonLinesSink for compressing log files efficiently.
• GoogleTest (gtest)
  Serves as the primary unit testing framework for the entire project.
• Google Benchmark
  Used to benchmark femtolog against other logging libraries to ensure high performance.
• fmtlib
  Powers the formatting engine behind all log message rendering.

Built with love by pugur.