🚀 ISO C++29 Standardization Candidate – The future of dimensional analysis in C++!

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!

Help shape the future of C++! Your testimonials help demonstrate real-world value to the ISO C++ Committee and other potential library users!

Whether you're using mp-units in production, research, or education:

• Organizations: Share your production deployments and success stories
• Academics: Report research applications and teaching experiences
• Developers: Tell us about your innovative use cases and benefits

Extensive project documentation is available on the project site. It includes:

• Installation instructions – Get up and running quickly
• Detailed user's guide – Comprehensive usage documentation
• Design rationale – Understanding the architectural decisions
• API reference – Complete technical documentation
• Tutorials – Step-by-step learning resources
• Examples – Real-world usage demonstrations

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.

• Type Safety – Strongly typed quantities, units, dimensions, and quantity points
• Zero Runtime Cost – Compile‑time dimensional analysis with no runtime overhead
• Unified Design – Comprehensive model for units, dimensions, quantities, and point origins
• Rich Text Formatting – Text formatting support with extensive options & character sets
• Flexible Usage – C++ modules support (when available) and header‑only usage
• Configurable – Contracts, freestanding mode, and natural units (experimental)
• Interoperable – Seamless pathways for legacy and external libraries

Here's a taste of what mp-units can do:

#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);

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.

Here's a broader preview showcasing mp-units 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
}

mp-units is available on Compiler Explorer for instant experimentation! Perfect for fast, zero‑setup trials and prototyping your ideas.

For advanced development or contributions, we provide a fully configured cloud development environment with GitHub Codespaces:

Alternatives:

1. Navigate to the repository → "Code" → "Codespaces" → "Create codespace on master"
2. Use the pre‑configured devcontainer and Docker image manually in your IDE

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

🥇 Recommended: We recommend using Conan to integrate mp-units with your project.

Multiple options available! Please refer to our comprehensive Installation and Usage Guide for all supported integration methods.

mp-units is made possible by our amazing community of contributors! 💪

• Mateusz Pusz – Project founder and lead
• Johel Ernesto Guerrero Peña – Core maintainer
• Chip Hogg – Core maintainer

We appreciate every contribution, from code to documentation to community support!

Ready to contribute? Check out our Contributing Guide to get started! 🚀

mp-units is developed as open source with the ambitious goal of C++29 standardization. Your support helps maintain development momentum and accelerate standardization efforts!

Ways to support:

• ⭐ Star the repository – Show your appreciation and help others discover mp-units
• 💰 Become a sponsor – Financial support enables continued development
• 📢 Share your success story – Help demonstrate real-world value for standardization and other potential users
• 🤝 Contribute – Code, documentation, feedback, and community support