# How to Use spdlog with Visual Studio: Complete Setup Guide

> Learn to use spdlog with Visual Studio easily. This guide covers setup, compiler settings, and immediate logging with the global API for your C++ projects.

- Repository: [Gabi Melman/spdlog](https://github.com/gabime/spdlog)
- Tags: how-to-guide
- Published: 2026-07-15

---

**To use spdlog with Visual Studio, add the `include/` directory to your project's *Additional Include Directories*, enable C++11 or later in the compiler settings, and include `<spdlog/spdlog.h>` to begin logging immediately with the global API.**

The `gabime/spdlog` repository provides a fast, header-only C++ logging library that integrates seamlessly with Microsoft Visual Studio. Because spdlog relies on C++11 features and bundles the **fmt** library for formatting, it works out of the box with MSVC toolsets from Visual Studio 2015 and later. You can consume spdlog as a header-only library for instant integration, or compile it as a static/shared library for faster build times in large projects.

## Installation and Project Setup

### Header-Only vs. Compiled Library Mode

spdlog offers two consumption modes in Visual Studio. **Header-only mode** requires only that you copy the `include/spdlog` folder from the repository into your project and point the compiler to it. This is the fastest way to start logging because implementations are inlined at compile time. Alternatively, **compiled library mode** requires building spdlog separately (using CMake) and linking the resulting `.lib` file, which reduces compilation overhead in large codebases.

To begin with header-only mode, download the latest release and place the `include` folder in your solution directory. In [`include/spdlog/spdlog.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/spdlog.h), you will find the central global API exposing functions like `spdlog::info()` and `spdlog::error()`.

### Configuring Include Directories

Open your Visual Studio project properties and navigate to **C/C++ > General**. Add the path to the spdlog `include` directory in **Additional Include Directories**. For example, if you placed spdlog in a `third_party` folder, add `$(SolutionDir)third_party\spdlog\include`.

Because spdlog bundles the **fmt** library inside `include/spdlog/fmt`, you do not need to download fmt separately when using header-only mode. The bundled headers are automatically referenced when you include spdlog components.

## Visual Studio Compiler Configuration

### Enabling C++11 or Later

spdlog requires C++11 support, which is enabled by default in Visual Studio 2015 and later. Verify your project uses a modern toolset by checking **Configuration Properties > General > Platform Toolset** (select `v140` or later). Under **C/C++ > Language**, ensure **C++ Language Standard** is set to **ISO C++11 Standard** (`/std:c++11`) or newer.

### Matching the Runtime Library

If you build spdlog as a compiled library, you must match the **Runtime Library** settings between spdlog and your project to avoid linker errors. In **C/C++ > Code Generation**, set **Runtime Library** to match how you built spdlog:

- `/MD` for Multi-threaded DLL (Release)
- `/MDd` for Multi-threaded Debug DLL (Debug)
- `/MT` for Multi-threaded (Release static)
- `/MTd` for Multi-threaded Debug (Debug static)

Mismatched runtimes (e.g., linking an `/MD` built spdlog with an `/MT` project) will cause unresolved external symbol errors during linking.

## Logging Implementation Examples

Once your include paths are configured, you can implement various logging patterns by including specific headers from the `include/spdlog` directory.

### Basic Global Logger (Header-Only)

Include `<spdlog/spdlog.h>` to use the global logger, which writes to stdout by default:

```cpp
#include "spdlog/spdlog.h"

int main()
{
    // Simple logging using the global registry
    spdlog::info("Hello from spdlog in Visual Studio!");
    spdlog::warn("A warning with a number: {}", 42);

    // Customize output pattern with timestamp, level, and thread ID
    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S] [%^%l%$] [thread %t] %v");
    spdlog::set_level(spdlog::level::debug);   // Enable debug output
    spdlog::debug("Debug message – now visible");
}

```

### Color Console Output

For color-enabled console logging that works in the Visual Studio terminal and Debug output window, include `<spdlog/sinks/stdout_color_sinks.h>` and instantiate `stdout_color_mt`:

```cpp
#include "spdlog/spdlog.h"
#include "spdlog/sinks/stdout_color_sinks.h"

int main()
{
    // Create a multi-threaded color console logger named "console"
    auto console = spdlog::stdout_color_mt("console");
    console->info("Info message in the Visual Studio terminal");
    console->error("Error message – appears in red");
}

```

### Rotating File Sinks

To create logs that rotate when they reach a specific size, include `<spdlog/sinks/rotating_file_sink.h>` and use `rotating_logger_mt`:

```cpp
#include "spdlog/spdlog.h"
#include "spdlog/sinks/rotating_file_sink.h"

int main()
{
    // 5 MiB per file, keep 3 rotated logs
    auto rotating = spdlog::rotating_logger_mt(
        "rotating", "logs/app.log", 5 * 1024 * 1024, 3);

    rotating->info("First entry in rotating log");
    rotating->warn("A warning that survives rotation");
}

```

### Asynchronous Logging

For high-performance applications, include `<spdlog/async.h>` and create an asynchronous logger with a background thread pool:

```cpp
#include "spdlog/spdlog.h"
#include "spdlog/async.h"
#include "spdlog/sinks/basic_file_sink.h"

int main()
{
    // Thread pool with queue size 8192 and 2 worker threads
    spdlog::init_thread_pool(8192, 2);
    
    auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>(
        "async_file", "logs/async.log");

    async_file->info("Logging from an async logger without blocking the main thread");
}

```

## Building spdlog as a Compiled Library

If you prefer not to use the header-only mode, you can generate a Visual Studio solution using the CMake file provided in [`example/CMakeLists.txt`](https://github.com/gabime/spdlog/blob/main/example/CMakeLists.txt). Open a Developer Command Prompt, navigate to the spdlog root, and run:

```bash
cmake -B build -S . -DSPDLOG_BUILD_SHARED=OFF
cmake --build build --config Release

```

This produces a static library (`spdlog.lib`) that you must link in your project by adding the library path to **Linker > General > Additional Library Directories** and adding `spdlog.lib` to **Linker > Input > Additional Dependencies**.

## Summary

- **Header-only integration** requires only adding `include/spdlog` to *Additional Include Directories*; no separate linking is needed because fmt is bundled in `include/spdlog/fmt`.
- **Compiled mode** requires building spdlog via CMake (see [`example/CMakeLists.txt`](https://github.com/gabime/spdlog/blob/main/example/CMakeLists.txt)), then matching your project's **Runtime Library** setting (`/MD`, `/MDd`, `/MT`, `/MTd`) to avoid linker errors.
- Core functionality resides in [`include/spdlog/spdlog.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/spdlog.h), with specialized sinks in `include/spdlog/sinks/` and async support in [`include/spdlog/async.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/async.h).
- Visual Studio 2015 and later are fully supported with C++11 or newer standards enabled.

## Frequently Asked Questions

### Does spdlog work with Visual Studio 2022?

Yes, spdlog is fully compatible with Visual Studio 2022, 2019, and 2017. The library requires C++11 support, which has been available in MSVC since Visual Studio 2015. Simply ensure your project targets a modern Platform Toolset (`v140` or later) and uses a C++ standard of at least C++11.

### Should I use header-only or compiled spdlog in Visual Studio?

Use **header-only mode** for small to medium projects where compile times are manageable and you want the simplest setup. Use **compiled mode** for large codebases where reducing compilation overhead is critical. In compiled mode, you must link against the `spdlog.lib` file and ensure your Runtime Library settings match exactly.

### How do I fix linker errors when using spdlog with Visual Studio?

Linker errors typically occur from mismatched **Runtime Library** settings. Check **Project Properties > C/C++ > Code Generation > Runtime Library** and ensure it matches the setting used when spdlog was built (`/MD` for DLL, `/MT` for static). If using header-only mode, ensure you are not accidentally linking against a precompiled spdlog library from an earlier attempt.

### Can spdlog output to the Visual Studio Debug Output window?

Yes, when using console sinks like `stdout_color_mt` or `stderr_color_mt` from [`include/spdlog/sinks/stdout_color_sinks.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/sinks/stdout_color_sinks.h), output appears in both the console and the Visual Studio **Output** window when running under the debugger. For exclusive Debug window output, you can create a custom sink using `OutputDebugString` from the Windows API, though the standard console sinks are sufficient for most debugging workflows.