# How the Dragonbox Algorithm Improves Floating-Point Formatting in {fmt} > Discover how the Dragonbox algorithm enhances floating-point formatting in fmtlib by using integer arithmetic for shortest decimal representation. Achieve correct rounding and round-trip safety efficiently. - Repository: [Hello World Foundation/fmt](https://github.com/fmtlib/fmt) - Tags: deep-dive - Published: 2026-09-09 --- **TLDR:** The Dragonbox algorithm enables {fmt} to convert IEEE-754 floating-point numbers to their shortest decimal representation using only integer arithmetic, guaranteeing correct rounding and round-trip safety without expensive floating-point divisions or logarithm calculations. The {fmt} library leverages the Dragonbox algorithm to solve the classic problem of binary-to-decimal floating-point conversion with unprecedented speed and correctness. Unlike older Grisu-based approaches or naive division methods that may produce verbose output or require costly fallbacks, Dragonbox guarantees the minimal decimal representation through pure integer operations implemented in [`include/fmt/format-inl.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format-inl.h). ## Why Dragonbox Outperforms Legacy Conversion Methods Traditional floating-point formatters rely on either division-based algorithms or the Grisu family of approximations. While Grisu improved upon division methods, it occasionally fails to produce the shortest decimal representation, forcing expensive fallback to exact algorithms. Dragonbox eliminates this trade-off by construction. According to the {fmt} source code, the algorithm achieves **O(1) time complexity** for the entire conversion pipeline. It replaces floating-point divisions with integer multiplications and bit-wise shifts, specifically utilizing `umul96_upper64` and `umul192_lower128` for extended precision arithmetic (see lines [198-204](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L198-L204)). ## Key Architectural Improvements ### Constant-Time Integer Arithmetic The core conversion logic resides entirely within integer domains. Functions like `umul96_upper64` and `umul192_lower128` handle 96-bit and 192-bit multiplication results without floating-point hardware, while `rotr` utilities manage bit rotation (lines [198-204](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L198-L204)). This approach avoids the performance penalty and rounding errors inherent in floating-point division units. ### Guaranteed Shortest Representation Dragonbox guarantees the minimal number of decimal digits required for round-trip safety. The implementation checks the shorter-interval case through `shorter_interval_case` (lines [1229-1275](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L1229-L1275)) and verifies rounding parity via `compute_mul_parity` (lines [50-55](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L50-L55)). This ensures the selected decimal is uniquely the nearest representation to the original binary value. ### Cache-Based Power-of-10 Lookup Rather than computing powers of 10 repeatedly through expensive logarithm calculations, {fmt} uses pre-computed caches. The `cache_accessor::get_cached_power` and `cache_accessor::get_cached_power` functions retrieve 64-bit and 128-bit significands from static constexpr arrays defined at line [99](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L99). This eliminates runtime computation of decimal exponents entirely. ### Platform-Independent Operation Because Dragonbox operates purely on integer types, it functions identically across 32-bit and 64-bit architectures without relying on floating-point hardware quirks. The `umul192_lower128` and rotation helpers abstract platform differences, ensuring consistent behavior whether targeting x86, ARM, or embedded microcontrollers. ## Implementation Details in {fmt} The public API exposes Dragonbox through a thin wrapper in [`include/fmt/format.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format.h): ```cpp template FMT_API auto to_decimal(T x) noexcept -> decimal_fp; ``` When instantiated for `float` or `double` in `src/format.cc` (lines [19-22](/fmtlib/fmt/blob/main/src/format.cc#L19-L22)), this template forwards to the Dragonbox converter. The returned `decimal_fp` structure contains the decimal mantissa and exponent, which the higher-level formatter renders into ASCII. The heavy lifting occurs in [`include/fmt/format-inl.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format-inl.h) starting at lines [208-210](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L208-L210), where the algorithm partitions the floating-point value, computes the required precision, and selects the optimal decimal representation using only integer operations. ## Practical Usage Example You can observe Dragonbox in action through the following example that demonstrates both high-level formatting and low-level access to the internal representation: ```cpp #include int main() { // High-level formatting uses Dragonbox automatically double d = 0.1; fmt::print("Decimal: {}\n", d); // Outputs: 0.1 // Access the Dragonbox decomposition directly auto dec = fmt::detail::dragonbox::to_decimal(d); fmt::print("Mantissa: {}, Exponent: {}\n", dec.f, dec.e); } ``` The output `0.1` represents the shortest correctly-rounded decimal that round-trips back to the original binary double-precision value. Without Dragonbox, many formatters would produce `0.10000000000000000555...` or similarly verbose output. ## Summary - **Dragonbox replaces floating-point divisions** with integer multiplications and shifts in [`include/fmt/format-inl.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format-inl.h), achieving O(1) conversion time. - **Correct rounding is guaranteed** through parity checks in `compute_mul_parity` and interval analysis in `shorter_interval_case`. - **Shortest representation** minimizes output length while maintaining round-trip safety, ensuring parsed values match the original binary exactly. - **Cache-based lookups** via `cache_accessor::get_cached_power` eliminate expensive logarithm calculations using pre-computed constexpr tables. - **Zero dynamic allocation** and platform-independent integer arithmetic make Dragonbox suitable for high-performance and embedded contexts. ## Frequently Asked Questions ### What makes Dragonbox faster than Grisu? Dragonbox achieves superior performance by using only integer arithmetic operations rather than floating-point divisions or modulo operations. While Grisu-style algorithms may require expensive fallback routines to handle edge cases, Dragonbox guarantees the shortest representation in constant time through precise interval analysis and multiplication-based scaling in `umul96_upper64` and related utilities. ### Does Dragonbox guarantee round-trip safety? Yes. The algorithm explicitly computes the shorter-interval case and verifies rounding parity using `compute_mul_parity` to ensure the selected decimal is the unique nearest neighbor to the original binary value. When parsed back, the decimal string produced by {fmt} always yields the exact original IEEE-754 floating-point number represented in the source binary. ### How does {fmt} handle different floating-point types with Dragonbox? The library uses template specializations and the `cache_accessor` pattern to provide optimized paths for both `float` and `double` types. The public `to_decimal` function in [`include/fmt/format.h`](https://github.com/fmtlib/fmt/blob/main/include/fmt/format.h) automatically dispatches to the appropriate Dragonbox implementation, while `src/format.cc` contains explicit instantiations for common types to reduce compile times and binary bloat. ### Is dynamic memory allocation required for Dragonbox conversion? No. The Dragonbox implementation in {fmt} uses only stack-allocated integer variables and constexpr cache tables embedded in the binary at line [99](/fmtlib/fmt/blob/main/include/fmt/format-inl.h#L99) of [`format-inl.h`](https://github.com/fmtlib/fmt/blob/main/format-inl.h). The conversion requires no heap allocation, making it suitable for real-time systems and environments where memory allocation is restricted or prohibited.