# fmtlib Roadmap: C++23 Conformance, Compile-Time Formatting, and Cross-Language Support

> Explore the fmtlib roadmap for C++23 conformance, compile-time formatting, cross-language support, and enhanced performance. Discover the future of C++ string formatting.

- Repository: [Hello World Foundation/fmt](https://github.com/fmtlib/fmt)
- Tags: roadmap
- Published: 2026-09-06

---

**TLDR:** The fmtlib roadmap focuses on achieving full C++23 `std::format` and `std::print` compliance, expanding zero-runtime-overhead compile-time formatting via `FMT_STATIC_FORMAT`, and stabilizing a C11-compatible API, while advancing SIMD-accelerated floating-point performance and universal Unicode handling.

The {fmt} library serves as the reference implementation for C++20's `<format>` and C++23's `<print>` standards, with active development ongoing in the `fmtlib/fmt` repository. The roadmap prioritizes moving more formatting work to compile time, broadening platform support through a stable C API, and maintaining performance leadership through SIMD optimizations. Recent changelogs indicate a strategic shift toward zero-overhead abstractions that maintain safety across language boundaries.

## C++ Standard Integration and Conformance

Recent releases have introduced full C++20 `std::format` compatibility and extensive C++23 `std::print` support. According to the source code in [`include/fmt/format.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format.h) and its implementation in `src/format.cc`, the library tracks the standard closely, with active work on color and style API overloads.

The roadmap targets finalizing C++23 conformance, including complete `std::format_to` overloads and seamless `import std` integration for module users. Future development will align the library's behavior exactly with the C++23 specification while maintaining backward compatibility for existing codebases.

## Compile-Time Formatting and Zero-Runtime Overhead

A primary roadmap priority is extending **compile-time formatting** capabilities for embedded and high-frequency applications. The [`include/fmt/compile.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/compile.h) header provides `FMT_STATIC_FORMAT` and user-defined literals for constexpr string generation.

The implementation enables format string parsing entirely at compile time without runtime overhead:

```cpp
#include <fmt/compile.h>
using namespace fmt::literals;

constexpr auto greeting = "Hello, {}"_cf;          // compile-time format string
constexpr std::string_view msg = fmt::format(greeting, "world");
// msg == "Hello, world"

```

Future work aims to expand constexpr support to more standard library types and enable full static allocation for environments that prohibit dynamic memory. The roadmap also includes exposing more granular compile-time diagnostics through enhanced const-eval checks in the core formatting engine.

## Cross-Language Support with the fmt-c API

The library now provides a **C11-compatible API** that enables type-safe formatting from C code using `_Generic` dispatch. Implemented in `src/fmt-c.cc` and declared in [`include/fmt/fmt-c.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/fmt-c.h), this interface opens fmtlib to language ecosystems beyond C++.

```c
#include <fmt/fmt-c.h>

int main() {
    fmt_print(stdout, "Pi ≈ {:.5}\n", 3.1415926535);
    // Output: Pi ≈ 3.14159
}

```

The roadmap prioritizes stabilizing this C API for production releases, adding optional UTF-8 handling for C callers, and distributing a lightweight header-only variant for pure C projects. This expansion positions the library as a universal formatting backend while maintaining the performance characteristics of the C++ implementation.

## Unicode, Localization, and Platform Support

Unicode handling is transitioning from opt-in to default behavior across all platforms. Recent modifications in [`include/fmt/os.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/os.h) provide correct formatting for `std::filesystem::path` objects containing Unicode characters, particularly on Windows with MSVC.

Future roadmap items include full Unicode normalization, locale-aware numeric grouping, and optional ICU integration. The library will maintain Unicode as the default while providing `FMT_UNICODE` flags and other mechanisms for low-footprint embedded builds that require restricted character sets.

## Performance Optimizations and SIMD

Performance remains central to the fmtlib roadmap, with ongoing enhancements to the **Dragonbox algorithm** for floating-point formatting. The implementation in `src/format.cc` includes cache optimizations and bulk-append strategies that reduce allocation overhead.

Upcoming development targets SIMD-based floating-point formatting, further reduction of allocation overhead through smarter buffer management, and optional `-ffast-math` pathways for compute-intensive applications. Range and container support will extend to native C++23 ranges integration and concepts-driven formatter selection, improving iterator performance as evidenced by recent optimizations to `fmt::join`.

## Build System and Ecosystem Improvements

The build system roadmap emphasizes supply-chain security and universal package manager support. Recent CMake configurations provide separate targets for `fmt-module`, `fmt-doc`, and core components, with improved Conan and Bazel integration.

Future releases will introduce SLSA provenance attestation for all binaries, optional `pkg-config` files for system-wide installations, and standardized distribution formats. The documentation in [`doc/api.md`](https://github.com/fmtlib/fmt/blob/main/doc/api.md) will continue to serve as the authoritative reference as the public API surface expands to accommodate C++23 features.

## Summary

- **Full C++23 compliance** targets complete implementation of `std::format`, `std::print`, and ranges formatting specifications.
- **Compile-time formatting** via [`include/fmt/compile.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/compile.h) expands constexpr support for embedded systems requiring zero dynamic allocation.
- **C API stabilization** in `src/fmt-c.cc` enables cross-language adoption through C11 `_Generic` type safety without runtime overhead.
- **Universal Unicode** becomes the default behavior while retaining opt-out mechanisms for constrained environments.
- **SIMD acceleration** and Dragonbox algorithm refinements maintain fmtlib's performance lead in floating-point and string formatting.

## Frequently Asked Questions

### Will fmtlib support asynchronous formatting for C++23 executors?

The roadmap includes architectural support for asynchronous formatting compatible with C++23 executor models. Current buffer management strategies in `src/format.cc` are being adapted for coroutine integration, though the immediate priority remains synchronous performance optimization and standard conformance.

### How does the C API handle type safety compared to standard printf?

The C API leverages C11 `_Generic` selection to provide compile-time type checking without runtime overhead, implemented in `src/fmt-c.cc`. Unlike traditional `printf`, which parses format strings at runtime, fmtlib's C interface validates types during compilation while using the same high-performance Dragonbox formatting engine as the C++ implementation.

### Is FMT_STATIC_FORMAT suitable for bare-metal embedded development?

Yes, `FMT_STATIC_FORMAT` and the utilities in [`include/fmt/compile.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/compile.h) are specifically engineered for bare-metal environments. These features generate constant expressions at compile time, eliminating heap allocation and enabling formatting in contexts where dynamic memory is prohibited or unavailable.

### What is the current status of C++ modules support?

C++20 modules are fully supported through the `fmt-module` CMake target and `import fmt` syntax. The roadmap includes deeper integration with `import std` to minimize compilation times, with module interface definitions maintained alongside traditional headers in `include/fmt/`.