quill
Quill is a C++17+ asynchronous logging library designed for ultra-low-latency, high-performance applications. It uses a lock-free backend thread to minimize blocking on the caller's side, with support for multiple output formats and metrics publishing.
Key facts
Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.
| Field | Value |
|---|---|
| Repository | odygrd/quill |
| Owner | odygrd |
| Primary language | C++ |
| License | MIT — OSI-approved |
| Stars | 3k |
| Forks | 263 |
| Open issues | 9 |
| Latest release | v12.0.0 (2026-06-13) |
| Last updated | 2026-07-08 |
| Source | https://github.com/odygrd/quill |
What quill is
Quill decouples logging calls from I/O via an asynchronous backend thread and lock-free queues. It supports C++17/20, offers macro and macro-free APIs, integrates with fmtlib for formatting, and provides Prometheus/StatsD/OpenTelemetry metrics publishing. Multi-platform CI confirms support for Linux, macOS, Windows, BSD, and Intel LLVM.
Get the quill source
Clone the repository and explore it locally.
git clone https://github.com/odygrd/quill.gitcd quill# follow the project's README for install & configurationNeed it deployed, integrated, or customized instead? DEV.co ships production installs.
Best use cases
Implementation considerations
- Ensure backend thread is started before logging; simple_logger() or Backend::start() must be called in main().
- Asynchronous nature means logs may buffer on shutdown; flush or wait for backend to ensure all messages are written.
- Lock-free queue design assumes typical CPU architectures; benchmark on your target platform if latency is critical.
- Macro API (LOG_INFO) offers lowest latency; macro-free API (quill::info) is slightly slower but more conventional code.
- Supports multiple sinks and loggers; configure via Frontend API for production use rather than simple_logger().
When to avoid it — and what to weigh
- You need C++11 or older — Quill requires C++17 minimum; older codebases would face forced upgrades or version lock.
- Synchronous, blocking log guarantees are mandatory — Asynchronous design means logs may not flush immediately; use standard libraries if all logs must be written before return.
- You prefer a pure header-only library — Quill is not header-only; it requires compilation and linking.
- Minimal external dependencies are a hard constraint — Depends on fmtlib and has platform-specific build requirements; lightweight alternatives exist.
License & commercial use
MIT License (OSI-approved, permissive). Permits commercial use, modification, and distribution with minimal restrictions; requires license and copyright notice in distributions.
MIT is a clear, permissive OSI license. Commercial use is permitted without special permission. Standard practice: include the MIT license text and copyright notice in distributions. No source-code disclosure required. No additional legal review needed for MIT.
DEV.co evaluation signals
Editorial assessment — not user reviews. Directional, with an explicit confidence level.
| Signal | Assessment |
|---|---|
| Maintenance | Active |
| Documentation | Strong |
| License clarity | Clear |
| Deployment complexity | Low |
| DEV.co fit | Strong |
| Assessment confidence | High |
Quill employs lock-free queue design and fuzzing pipeline (visible in CI) to catch edge cases. No disclosed CVEs or critical issues in public data. Asynchronous architecture reduces deadlock risk in logging hot paths. Consider: (1) backend thread shares memory with logging threads—typical race conditions apply; (2) no explicit memory-tagging or isolation guarantees stated; (3) input validation for format strings deferred to fmtlib—review fmtlib's security posture. No privileged operations stated; suitable for sandboxed/container deployments.
Alternatives to consider
spdlog
Popular, widely-used C++ logging library; lower latency claims than traditional loggers, simpler API. Less focused on ultra-low-latency trading/finance use cases; smaller community than Quill's niche.
Boost.Log
Part of Boost ecosystem; feature-rich, well-established. Heavier dependency footprint, steeper learning curve, less optimized for microsecond-latency scenarios.
glog (Google Logging)
Lightweight, from Google; used in large production systems. Simpler design, less async control; targets logging infrastructure over extreme latency optimization.
Build on quill with DEV.co software developers
Quill is battle-tested in production and available via vcpkg, Conan, and other package managers. Get started in minutes with simple_logger() or scale to production with the Backend API.
Talk to DEV.coRelated open-source tools
Surfaced by semantic similarity across the DEV.co open-source index.
Related on DEV.co
Explore the category and the services that help you build with it.
quill FAQ
Does Quill guarantee all logs are written before main() exits?
Can I use Quill in a multi-threaded application?
What is the minimum C++ version required?
How do I compare latency between Quill and my current logger?
Software developers & web developers for hire
Adopting quill is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate open-source observability software in production.
Eliminate Logging Latency in Your C++ Application
Quill is battle-tested in production and available via vcpkg, Conan, and other package managers. Get started in minutes with simple_logger() or scale to production with the Backend API.