# How to Check the fmtlib Version in C++: Compile-Time and Runtime Methods

> Learn how to check the fmtlib version in C++ using compile-time macros like FMT_VERSION and runtime methods. Discover the integer encoding for major minor patch releases.

- Repository: [Hello World Foundation/fmt](https://github.com/fmtlib/fmt)
- Tags: how-to-guide
- Published: 2026-09-12

---

**The fmtlib version is defined as the macro `FMT_VERSION` in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h), with the current release encoding version 12.2.1 as the integer `120201` using the formula major×10000 + minor×100 + patch.**

The {fmt} library is a fast, open-source C++ formatting library that provides a safe and extensible alternative to `printf` and `iostream`. Accessing the library version at compile time is essential for feature detection, conditional compilation, and diagnostic logging in cross-platform applications.

## Where the fmtlib Version is Defined

### The FMT_VERSION Macro in core.h

The authoritative source for the fmtlib version is located in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h) at lines 23-25. The library exposes a single integer macro that encodes the semantic version components:

```cpp
#define FMT_VERSION 120201

```

This definition is part of the core API introduced in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h), making it available to any translation unit that includes the header. The value is an integer literal rather than a string, enabling direct comparison operations in preprocessor conditionals.

## How to Decode the fmtlib Version Number

The fmtlib project uses a compact integer encoding scheme to represent semantic versioning. The formula is:

**major × 10000 + minor × 100 + patch**

Breaking down the current value `120201`:

- **Major**: 120201 ÷ 10000 = **12**
- **Minor**: (120201 % 10000) ÷ 100 = **2**
- **Patch**: 120201 % 100 = **1**

Thus, `FMT_VERSION 120201` represents fmtlib **12.2.1**.

## Practical Code Examples

### Print the Version at Runtime

You can extract and display the version components using standard integer arithmetic:

```cpp
#include <fmt/core.h>
#include <iostream>

int main() {
    int major = FMT_VERSION / 10000;
    int minor = (FMT_VERSION % 10000) / 100;
    int patch = FMT_VERSION % 100;
    std::cout << "fmt version: " << major << '.' << minor << '.' << patch << '\n';
}

```

This approach requires no runtime dependencies beyond the header itself, making it suitable for initialization logging and diagnostic reporting.

### Compile-Time Feature Gating

Use the macro in preprocessor directives to conditionally enable features based on the library version:

```cpp
#include <fmt/core.h>

#if FMT_VERSION >= 120200   // Require at least fmt 12.2.0
    #define HAVE_NEW_API
#endif

#ifdef HAVE_NEW_API
static_assert(true, "New API is available");
#endif

```

This pattern is critical for maintaining compatibility across different fmtlib versions in header-only or statically linked projects.

### Embed Version in Formatted Output

Leverage the library's own formatting capabilities to print the version string:

```cpp
#include <fmt/core.h>

int main() {
    fmt::print("Running fmt {}.{}.{}\n",
               FMT_VERSION / 10000,
               (FMT_VERSION % 10000) / 100,
               FMT_VERSION % 100);
}

```

This demonstrates how to use the `fmt::print` function while simultaneously reporting the library version that provides it.

## Build System Integration

The version defined in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h) is propagated to the build system through [`CMakeLists.txt`](https://github.com/fmtlib/fmt/blob/main/CMakeLists.txt). The CMake configuration reads the header definition to ensure consistency between the compiled library and the headers, generating appropriate `FMT_VERSION` definitions for consumers. For historical context and migration notes, consult [`ChangeLog.md`](https://github.com/fmtlib/fmt/blob/main/ChangeLog.md), which records the version history and breaking changes for each release.

## Summary

- The fmtlib version is defined as `FMT_VERSION` in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h) at lines 23-25.
- The current version 12.2.1 is encoded as the integer `120201`.
- The encoding formula is **major×10000 + minor×100 + patch**, enabling simple preprocessor arithmetic.
- You can check the version at compile time using `#if FMT_VERSION >= XXXXXX` for conditional compilation.
- Runtime version extraction requires dividing the macro by 10000 and 100 to isolate major, minor, and patch components.

## Frequently Asked Questions

### How do I find my installed fmtlib version?

Include [`fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/fmt/core.h) and check the value of `FMT_VERSION`. Divide the integer by 10000 to get the major version, or use the modulo operations described above to extract all three components. If you installed fmtlib via a package manager, you can also check [`ChangeLog.md`](https://github.com/fmtlib/fmt/blob/main/ChangeLog.md) in the installation directory to see the release notes for your specific version.

### What version format does fmtlib use?

fmtlib uses a three-component semantic versioning scheme (major.minor.patch) encoded into a single integer. The encoding places the major version in the ten-thousands place, the minor version in the hundreds place, and the patch version in the ones place. This compact representation allows for efficient compile-time comparisons using standard C preprocessor operators.

### Can I check the fmtlib version at compile time?

Yes. Because `FMT_VERSION` is a preprocessor macro defined in [`include/fmt/core.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/core.h), you can use it in `#if` directives to conditionally compile code based on the available library version. This is the recommended approach for writing portable code that supports multiple fmtlib releases, particularly when using features introduced in specific versions.

### Where is the fmtlib version history documented?

The complete version history is recorded in [`ChangeLog.md`](https://github.com/fmtlib/fmt/blob/main/ChangeLog.md) at the repository root. This file contains detailed release notes, breaking changes, and new features introduced in each version. The [`README.md`](https://github.com/fmtlib/fmt/blob/main/README.md) file also provides an overview of the library's goals and current capabilities, though specific version details reside in the changelog and the `FMT_VERSION` macro definition.