The mp-units library is a candidate for ISO standardization for C++29. More context can be found in the following ISO C++ proposals:

• P1935: A C++ Approach to Physical Units,
• P2980: A motivation, scope, and plan for a quantities and units library,
• P3045: Quantities and units library.

We are actively seeking organizations and individuals interested in field‑trialing the library.

Extensive project documentation is available on the project site. It includes installation instructions, a detailed user's guide, design rationale, an API reference, tutorials, and examples.

If you're new and just want to experiment, jump to the TL;DR below.

mp-units is a Modern C++ (C++20 and later) library providing compile‑time dimensional analysis and safe manipulation of units, quantities, and quantity points.

• Strongly typed quantities, units, dimensions, and quantity points (affine space)
• Compile‑time dimensional analysis and conversion with no runtime overhead
• Unified model for units, dimensions, quantity specifications, and origins
• Quantity, unit, and dimension text formatting (portable & UTF‑8 aware)
• C++ modules support (when available) and header‑only usage
• Configurable contracts, freestanding mode, and natural units (experimental)
• Interoperability pathways for legacy and external libraries

Here is a small example of typical operations:

#include <mp-units/systems/si.h>

using namespace mp_units;
using namespace mp_units::si::unit_symbols;

// simple numeric operations
static_assert(10 * km / 2 == 5 * km);

// conversions to common units
static_assert(1 * h == 3600 * s);
static_assert(1 * km + 1 * m == 1001 * m);

// derived quantities
static_assert(1 * km / (1 * s) == 1000 * m / s);
static_assert(2 * km / h * (2 * h) == 4 * km);
static_assert(2 * km / (2 * km / h) == 1 * h);

static_assert(2 * m * (3 * m) == 6 * m2);

static_assert(10 * km / (5 * km) == 2 * one);

static_assert(1000 / (1 * s) == 1 * kHz);

Try it on the Compiler Explorer.

The library makes extensive use of C++20 features (concepts, class types as NTTPs, etc.). This enables powerful yet easy‑to‑use interfaces while performing all conversions and dimensional analysis at compile time—without sacrificing runtime performance or accuracy.

The example below shows a broader preview of basic capabilities:

#include <mp-units/systems/international.h>
#include <mp-units/systems/isq.h>
#include <mp-units/systems/si.h>
#include <format>
#include <iomanip>
#include <iostream>
#include <print>

using namespace mp_units;

constexpr QuantityOf<isq::speed> auto avg_speed(QuantityOf<isq::length> auto d,
                                                QuantityOf<isq::time> auto t)
{
  return d / t;
}

int main()
{
  using namespace mp_units::si::unit_symbols;
  using namespace mp_units::international::unit_symbols;

  constexpr quantity v1 = 110 * km / h;
  constexpr quantity v2 = 70 * mph;
  constexpr quantity v3 = avg_speed(220. * isq::distance[km], 2 * h);
  constexpr quantity v4 = avg_speed(isq::distance(140. * mi), 2 * h);
  constexpr quantity v5 = v3.in(m / s);
  constexpr quantity v6 = value_cast<m / s>(v4);
  constexpr quantity v7 = value_cast<int>(v6);

  std::cout << v1 << '\n';                                        // 110 km/h
  std::cout << std::setw(10) << std::setfill('*') << v2 << '\n';  // ***70 mi/h
  std::cout << std::format("{:*^10}\n", v3);                      // *110 km/h*
  std::println("{:%N in %U of %D}", v4);                          // 70 in mi/h of LT⁻¹
  std::println("{::N[.2f]}", v5);                                 // 30.56 m/s
  std::println("{::N[.2f]U[dn]}", v6);                            // 31.29 m⋅s⁻¹
  std::println("{:%N}", v7);                                      // 31
}

Try it on the Compiler Explorer.

As seen in the previous chapter, mp-units is available on Compiler Explorer. Use it for a fast, zero‑setup trial or to prototype ideas.

For more advanced development or contributions, we encourage you to use our pre‑configured GitHub Codespaces environment. You can either click the button below

or navigate to the repository main page and click “Code” → “Codespaces” → “Create codespace on master”.

You can also use the pre‑configured devcontainer and Docker image manually within your IDE.

For detailed environment documentation, see .devcontainer/README.md.

We recommend using Conan to integrate mp-units with your project. However, there are also other ways to make it work. Please refer to our Installation and Usage documentation chapter for more details.