diff --git a/docs/blog/posts/2.1.0-released.md b/docs/blog/posts/2.1.0-released.md
index 3138e833..e8a675f0 100644
--- a/docs/blog/posts/2.1.0-released.md
+++ b/docs/blog/posts/2.1.0-released.md
@@ -49,19 +49,19 @@ As a side effect, we introduced a :boom: **breaking change** :boom:. We can't us
 hertz anymore:
 
 ```cpp
-inline constexpr struct hertz : named_unit<"Hz", 1 / second, kind_of<isq::frequency>> {} hertz;
+constexpr struct hertz : named_unit<"Hz", 1 / second, kind_of<isq::frequency>> {} hertz;
 ```
 
 and have to type either:
 
 ```cpp
-inline constexpr struct hertz : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
+constexpr struct hertz : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
 ```
 
 or
 
 ```cpp
-inline constexpr struct hertz : named_unit<"Hz", inverse(second), kind_of<isq::frequency>> {} hertz;
+constexpr struct hertz : named_unit<"Hz", inverse(second), kind_of<isq::frequency>> {} hertz;
 ```
 
 To be consistent, we applied the same change to the dimensions and quantity
@@ -70,13 +70,13 @@ specifications definitions. Now, to define a _frequency_ we have to type:
 === "C++23"
 
     ```cpp
-    inline constexpr struct frequency : quantity_spec<inverse(period_duration)> {} frequency;
+    constexpr struct frequency : quantity_spec<inverse(period_duration)> {} frequency;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct frequency : quantity_spec<frequency, inverse(period_duration)> {} frequency;
+    constexpr struct frequency : quantity_spec<frequency, inverse(period_duration)> {} frequency;
     ```
 
 === "Portable"
@@ -145,11 +145,11 @@ If we derive from the same instantiation of `absolute_point_origin` we end up wi
 point origin. This change allows us to provide different names for the same temperature points:
 
 ```cpp
-inline constexpr struct absolute_zero : absolute_point_origin<absolute_zero, isq::thermodynamic_temperature> {} absolute_zero;
-inline constexpr struct zeroth_kelvin : decltype(absolute_zero) {} zeroth_kelvin;
+constexpr struct absolute_zero : absolute_point_origin<absolute_zero, isq::thermodynamic_temperature> {} absolute_zero;
+constexpr struct zeroth_kelvin : decltype(absolute_zero) {} zeroth_kelvin;
 
-inline constexpr struct ice_point : relative_point_origin<absolute_zero + 273.15 * kelvin> {} ice_point;
-inline constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius;
+constexpr struct ice_point : relative_point_origin<absolute_zero + 273.15 * kelvin> {} ice_point;
+constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius;
 ```
 
 Please note that this is a :boom: **breaking change** :boom: as well.
diff --git a/docs/blog/posts/2.2.0-released.md b/docs/blog/posts/2.2.0-released.md
index 451a1f53..55b8edd4 100644
--- a/docs/blog/posts/2.2.0-released.md
+++ b/docs/blog/posts/2.2.0-released.md
@@ -281,13 +281,13 @@ is why it was renamed to `symbol_text` (:boom: **breaking change** :boom:).
 === "Now"
 
     ```cpp
-    inline constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
+    constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
     ```
 
 === "Before"
 
     ```cpp
-    inline constexpr struct ohm : named_unit<basic_symbol_text{"Ω", "ohm"}, volt / ampere> {} ohm;
+    constexpr struct ohm : named_unit<basic_symbol_text{"Ω", "ohm"}, volt / ampere> {} ohm;
     ```
 
 !!! note
@@ -295,7 +295,7 @@ is why it was renamed to `symbol_text` (:boom: **breaking change** :boom:).
     On C++20-compliant compilers it should be enough to type the following in the unit's definition:
 
     ```cpp
-    inline constexpr struct ohm final : named_unit<{u8"Ω", "ohm"}, volt / ampere> {} ohm;
+    constexpr struct ohm final : named_unit<{u8"Ω", "ohm"}, volt / ampere> {} ohm;
     ```
 
 
@@ -307,31 +307,31 @@ marked `final` (:boom: **breaking change** :boom:).
 === "Now"
 
     ```cpp
-    inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
-    inline constexpr struct length final : quantity_spec<dim_length> {} length;
+    constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+    constexpr struct length final : quantity_spec<dim_length> {} length;
 
-    inline constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
-    inline constexpr auto zeroth_kelvin  = absolute_zero;
-    inline constexpr struct kelvin final : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
+    constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
+    constexpr auto zeroth_kelvin  = absolute_zero;
+    constexpr struct kelvin final : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
 
-    inline constexpr struct ice_point final : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
-    inline constexpr auto zeroth_degree_Celsius = ice_point;
-    inline constexpr struct degree_Celsius final : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
+    constexpr struct ice_point final : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
+    constexpr auto zeroth_degree_Celsius = ice_point;
+    constexpr struct degree_Celsius final : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
     ```
 
 === "Before"
 
     ```cpp
-    inline constexpr struct dim_length : base_dimension<"L"> {} dim_length;
-    inline constexpr struct length : quantity_spec<dim_length> {} length;
+    constexpr struct dim_length : base_dimension<"L"> {} dim_length;
+    constexpr struct length : quantity_spec<dim_length> {} length;
 
-    inline constexpr struct absolute_zero : absolute_point_origin<absolute_zero, isq::thermodynamic_temperature> {} absolute_zero;
-    inline constexpr struct zeroth_kelvin : decltype(absolute_zero) {} zeroth_kelvin;
-    inline constexpr struct kelvin : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
+    constexpr struct absolute_zero : absolute_point_origin<absolute_zero, isq::thermodynamic_temperature> {} absolute_zero;
+    constexpr struct zeroth_kelvin : decltype(absolute_zero) {} zeroth_kelvin;
+    constexpr struct kelvin : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
 
-    inline constexpr struct ice_point : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
-    inline constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius;
-    inline constexpr struct degree_Celsius : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
+    constexpr struct ice_point : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
+    constexpr struct zeroth_degree_Celsius : decltype(ice_point) {} zeroth_degree_Celsius;
+    constexpr struct degree_Celsius : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
     ```
 
 Please also note, that the `absolute_point_origin` does not use CRTP idiom anymore (:boom: **breaking change** :boom:).
@@ -509,13 +509,13 @@ conversion factor. Here is a comparison of the code with previous and current de
 === "Now"
 
     ```cpp
-    inline constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
-    inline constexpr struct foot final : named_unit<"ft", mag_ratio<1, 3> * yard> {} foot;
+    constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
+    constexpr struct foot final : named_unit<"ft", mag_ratio<1, 3> * yard> {} foot;
     ```
 
 === "Before"
 
     ```cpp
-    inline constexpr struct yard : named_unit<"yd", mag<ratio{9'144, 10'000}> * si::metre> {} yard;
-    inline constexpr struct foot : named_unit<"ft", mag<ratio{1, 3}> * yard> {} foot;
+    constexpr struct yard : named_unit<"yd", mag<ratio{9'144, 10'000}> * si::metre> {} yard;
+    constexpr struct foot : named_unit<"ft", mag<ratio{1, 3}> * yard> {} foot;
     ```
diff --git a/docs/index.md b/docs/index.md
index 260316e1..bfd1a221 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -33,7 +33,7 @@ The library source code is hosted on [GitHub](https://github.com/mpusz/mp-units)
 
     using namespace mp_units;
 
-    inline constexpr struct smoot final : named_unit<"smoot", mag<67> * usc::inch> {} smoot;
+    constexpr struct smoot final : named_unit<"smoot", mag<67> * usc::inch> {} smoot;
 
     int main()
     {
@@ -53,7 +53,7 @@ The library source code is hosted on [GitHub](https://github.com/mpusz/mp-units)
 
     using namespace mp_units;
 
-    inline constexpr struct smoot final : named_unit<"smoot", mag<67> * usc::inch> {} smoot;
+    constexpr struct smoot final : named_unit<"smoot", mag<67> * usc::inch> {} smoot;
 
     int main()
     {
diff --git a/docs/users_guide/framework_basics/character_of_a_quantity.md b/docs/users_guide/framework_basics/character_of_a_quantity.md
index 26b358af..3934cfda 100644
--- a/docs/users_guide/framework_basics/character_of_a_quantity.md
+++ b/docs/users_guide/framework_basics/character_of_a_quantity.md
@@ -97,15 +97,15 @@ enumeration can be appended to the `quantity_spec` describing such a quantity ty
 === "C++23"
 
     ```cpp
-    inline constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
-    inline constexpr struct displacement final : quantity_spec<length, quantity_character::vector> {} displacement;
+    constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
+    constexpr struct displacement final : quantity_spec<length, quantity_character::vector> {} displacement;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct position_vector final : quantity_spec<position_vector, length, quantity_character::vector> {} position_vector;
-    inline constexpr struct displacement final : quantity_spec<displacement, length, quantity_character::vector> {} displacement;
+    constexpr struct position_vector final : quantity_spec<position_vector, length, quantity_character::vector> {} position_vector;
+    constexpr struct displacement final : quantity_spec<displacement, length, quantity_character::vector> {} displacement;
     ```
 
 === "Portable"
@@ -126,13 +126,13 @@ character override is needed):
 === "C++23"
 
     ```cpp
-    inline constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
+    constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct velocity final : quantity_spec<velocity, speed, position_vector / duration> {} velocity;
+    constexpr struct velocity final : quantity_spec<velocity, speed, position_vector / duration> {} velocity;
     ```
 
 === "Portable"
@@ -179,7 +179,7 @@ For example, here is how it can be done for the [P1385](https://wg21.link/p1385)
 using la_vector = STD_LA::fixed_size_column_vector<double, 3>;
 
 template<>
-inline constexpr bool mp_units::is_vector<la_vector> = true;
+constexpr bool mp_units::is_vector<la_vector> = true;
 ```
 
 With the above, we can use `la_vector` as a representation type for our quantity:
@@ -233,7 +233,7 @@ For example, we can do the following:
 ```cpp
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 ```
 
 which says that every type that can be used as a scalar representation is also allowed for vector
diff --git a/docs/users_guide/framework_basics/concepts.md b/docs/users_guide/framework_basics/concepts.md
index dd09e673..1fce6016 100644
--- a/docs/users_guide/framework_basics/concepts.md
+++ b/docs/users_guide/framework_basics/concepts.md
@@ -180,7 +180,7 @@ with `true` for one or more of the following variable templates:
     ```cpp
     template<class T>
       requires mp_units::is_scalar<T>
-    inline constexpr bool mp_units::is_vector<T> = true;
+    constexpr bool mp_units::is_vector<T> = true;
     ```
 
 
@@ -219,7 +219,7 @@ implicitly convertible from quantity specification `V`, which means that `V` mus
     However, if we define `mean_sea_level` in the following way:
 
     ```cpp
-    inline constexpr struct mean_sea_level final : absolute_point_origin<isq::altitude> {} mean_sea_level;
+    constexpr struct mean_sea_level final : absolute_point_origin<isq::altitude> {} mean_sea_level;
     ```
 
     then it can't be used as a point origin for _points_ of `isq::length` or `isq::width` as none of them
diff --git a/docs/users_guide/framework_basics/design_overview.md b/docs/users_guide/framework_basics/design_overview.md
index 4d2f9850..c820c1a6 100644
--- a/docs/users_guide/framework_basics/design_overview.md
+++ b/docs/users_guide/framework_basics/design_overview.md
@@ -60,8 +60,8 @@ For example:
 the following way:
 
 ```cpp
-inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
-inline constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
+constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
 ```
 
 [Derived dimensions](../../appendix/glossary.md#derived-dimension) are implicitly created
@@ -71,9 +71,9 @@ provided in the [quantity specification](../../appendix/glossary.md#quantity_spe
 === "C++23"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<dim_length> {} length;
-    inline constexpr struct time final : quantity_spec<dim_time> {} time;
-    inline constexpr struct speed final : quantity_spec<length / time> {} speed;
+    constexpr struct length final : quantity_spec<dim_length> {} length;
+    constexpr struct time final : quantity_spec<dim_time> {} time;
+    constexpr struct speed final : quantity_spec<length / time> {} speed;
 
     static_assert(speed.dimension == dim_length / dim_time);
     ```
@@ -81,9 +81,9 @@ provided in the [quantity specification](../../appendix/glossary.md#quantity_spe
 === "C++20"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<length, dim_length> {} length;
-    inline constexpr struct time final : quantity_spec<time, dim_time> {} time;
-    inline constexpr struct speed final : quantity_spec<speed, length / time> {} speed;
+    constexpr struct length final : quantity_spec<length, dim_length> {} length;
+    constexpr struct time final : quantity_spec<time, dim_time> {} time;
+    constexpr struct speed final : quantity_spec<speed, length / time> {} speed;
 
     static_assert(speed.dimension == dim_length / dim_time);
     ```
@@ -183,17 +183,17 @@ Quantity specification  can be defined by the user in one of the following ways:
 === "C++23"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<dim_length> {} length;
-    inline constexpr struct height final : quantity_spec<length> {} height;
-    inline constexpr struct speed final : quantity_spec<length / time> {} speed;
+    constexpr struct length final : quantity_spec<dim_length> {} length;
+    constexpr struct height final : quantity_spec<length> {} height;
+    constexpr struct speed final : quantity_spec<length / time> {} speed;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<length, dim_length> {} length;
-    inline constexpr struct height final : quantity_spec<height, length> {} height;
-    inline constexpr struct speed final : quantity_spec<speed, length / time> {} speed;
+    constexpr struct length final : quantity_spec<length, dim_length> {} length;
+    constexpr struct height final : quantity_spec<height, length> {} height;
+    constexpr struct speed final : quantity_spec<speed, length / time> {} speed;
     ```
 
 === "Portable"
@@ -232,15 +232,15 @@ A unit can be defined by the user in one of the following ways:
 
 ```cpp
 template<PrefixableUnit U> struct kilo_ : prefixed_unit<"k", mag_power<10, 3>, U{}> {};
-template<PrefixableUnit auto U> inline constexpr kilo_<decltype(U)> kilo;
+template<PrefixableUnit auto U> constexpr kilo_<decltype(U)> kilo;
 
-inline constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
-inline constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
-inline constexpr struct gram   final : named_unit<"g", kind_of<isq::mass>> {} gram;
-inline constexpr auto kilogram = kilo<gram>;
-inline constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
+constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
+constexpr struct gram   final : named_unit<"g", kind_of<isq::mass>> {} gram;
+constexpr auto kilogram = kilo<gram>;
+constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
 
-inline constexpr struct speed_of_light_in_vacuum final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
+constexpr struct speed_of_light_in_vacuum final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
 ```
 
 The [unit equation](../../appendix/glossary.md#unit-equation) of `si::metre / si::second` results
@@ -346,13 +346,13 @@ For example:
 - the absolute point origin can be defined in the following way:
 
   ```cpp
-  inline constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
+  constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
   ```
 
 - the relative point origin can be defined in the following way:
 
   ```cpp
-  inline constexpr struct ice_point final : relative_point_origin<absolute_zero + 273'150 * milli<kelvin>> {} ice_point;
+  constexpr struct ice_point final : relative_point_origin<absolute_zero + 273'150 * milli<kelvin>> {} ice_point;
   ```
 
 
diff --git a/docs/users_guide/framework_basics/dimensionless_quantities.md b/docs/users_guide/framework_basics/dimensionless_quantities.md
index 3cb3d089..2c997222 100644
--- a/docs/users_guide/framework_basics/dimensionless_quantities.md
+++ b/docs/users_guide/framework_basics/dimensionless_quantities.md
@@ -113,7 +113,7 @@ that uses a unit that is proportional to the ratio of kilometers per megaparsecs
 units of _length_:
 
 ```cpp
-inline constexpr struct hubble_constant final :
+constexpr struct hubble_constant final :
     named_unit<{u8"H₀", "H_0"}, mag_ratio<701, 10> * si::kilo<si::metre> / si::second / si::mega<parsec>> {} hubble_constant;
 ```
 
@@ -158,10 +158,10 @@ Besides the unit `one`, there are a few other scaled units predefined in the lib
 with dimensionless quantities:
 
 ```cpp
-inline constexpr struct percent final : named_unit<"%", mag_ratio<1, 100> * one> {} percent;
-inline constexpr struct per_mille final : named_unit<{u8"‰", "%o"}, mag_ratio<1, 1000> * one> {} per_mille;
-inline constexpr struct parts_per_million final : named_unit<"ppm", mag_ratio<1, 1'000'000> * one> {} parts_per_million;
-inline constexpr auto ppm = parts_per_million;
+constexpr struct percent final : named_unit<"%", mag_ratio<1, 100> * one> {} percent;
+constexpr struct per_mille final : named_unit<{u8"‰", "%o"}, mag_ratio<1, 1000> * one> {} per_mille;
+constexpr struct parts_per_million final : named_unit<"ppm", mag_ratio<1, 1'000'000> * one> {} parts_per_million;
+constexpr auto ppm = parts_per_million;
 ```
 
 ### Superpowers of the unit `one`
@@ -271,17 +271,17 @@ to the quantity specification:
 === "C++23"
 
     ```cpp
-    inline constexpr struct angular_measure final : quantity_spec<dimensionless, arc_length / radius, is_kind> {} angular_measure;
-    inline constexpr struct solid_angular_measure final : quantity_spec<dimensionless, area / pow<2>(radius), is_kind> {} solid_angular_measure;
-    inline constexpr struct storage_capacity final : quantity_spec<dimensionless, is_kind> {} storage_capacity;
+    constexpr struct angular_measure final : quantity_spec<dimensionless, arc_length / radius, is_kind> {} angular_measure;
+    constexpr struct solid_angular_measure final : quantity_spec<dimensionless, area / pow<2>(radius), is_kind> {} solid_angular_measure;
+    constexpr struct storage_capacity final : quantity_spec<dimensionless, is_kind> {} storage_capacity;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct angular_measure final : quantity_spec<angular_measure, dimensionless, arc_length / radius, is_kind> {} angular_measure;
-    inline constexpr struct solid_angular_measure final : quantity_spec<solid_angular_measure, dimensionless, area / pow<2>(radius), is_kind> {} solid_angular_measure;
-    inline constexpr struct storage_capacity final : quantity_spec<storage_capacity, dimensionless, is_kind> {} storage_capacity;
+    constexpr struct angular_measure final : quantity_spec<angular_measure, dimensionless, arc_length / radius, is_kind> {} angular_measure;
+    constexpr struct solid_angular_measure final : quantity_spec<solid_angular_measure, dimensionless, area / pow<2>(radius), is_kind> {} solid_angular_measure;
+    constexpr struct storage_capacity final : quantity_spec<storage_capacity, dimensionless, is_kind> {} storage_capacity;
     ```
 
 === "Portable"
@@ -296,9 +296,9 @@ With the above, we can constrain `radian`, `steradian`, and `bit` to be allowed
 specific quantity kinds only:
 
 ```cpp
-inline constexpr struct radian final : named_unit<"rad", metre / metre, kind_of<isq::angular_measure>> {} radian;
-inline constexpr struct steradian final : named_unit<"sr", square(metre) / square(metre), kind_of<isq::solid_angular_measure>> {} steradian;
-inline constexpr struct bit final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
+constexpr struct radian final : named_unit<"rad", metre / metre, kind_of<isq::angular_measure>> {} radian;
+constexpr struct steradian final : named_unit<"sr", square(metre) / square(metre), kind_of<isq::solid_angular_measure>> {} steradian;
+constexpr struct bit final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
 ```
 
 but still allow the usage of `one` and its scaled versions for such quantities.
diff --git a/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md b/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md
index cef490db..5dd8c3eb 100644
--- a/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md
+++ b/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md
@@ -39,12 +39,12 @@ namespace si {
 
 namespace si2019 {
 
-inline constexpr struct speed_of_light_in_vacuum final :
+constexpr struct speed_of_light_in_vacuum final :
   named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
 
 }  // namespace si2019
 
-inline constexpr struct magnetic_constant final :
+constexpr struct magnetic_constant final :
   named_unit<{u8"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant;
 
 }  // namespace mp_units::si
diff --git a/docs/users_guide/framework_basics/interface_introduction.md b/docs/users_guide/framework_basics/interface_introduction.md
index 31ebef0a..b7c6a2e5 100644
--- a/docs/users_guide/framework_basics/interface_introduction.md
+++ b/docs/users_guide/framework_basics/interface_introduction.md
@@ -6,8 +6,8 @@ The **mp-units** library decided to use a rather unusual pattern to define entit
 Here is how we define `metre` and `second` [SI](../../appendix/glossary.md#si) base units:
 
 ```cpp
-inline constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
-inline constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
+constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
+constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
 ```
 
 Please note that the above reuses the same identifier for a type and its value. The rationale
@@ -97,9 +97,9 @@ the value-based [unit equation](../../appendix/glossary.md#unit-equation) to a c
 definition:
 
 ```cpp
-inline constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
-inline constexpr struct pascal final : named_unit<"Pa", newton / square(metre)> {} pascal;
-inline constexpr struct joule  final : named_unit<"J", newton * metre> {} joule;
+constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+constexpr struct pascal final : named_unit<"Pa", newton / square(metre)> {} pascal;
+constexpr struct joule  final : named_unit<"J", newton * metre> {} joule;
 ```
 
 
diff --git a/docs/users_guide/framework_basics/simple_and_typed_quantities.md b/docs/users_guide/framework_basics/simple_and_typed_quantities.md
index 178c36e2..7dcf645d 100644
--- a/docs/users_guide/framework_basics/simple_and_typed_quantities.md
+++ b/docs/users_guide/framework_basics/simple_and_typed_quantities.md
@@ -316,12 +316,12 @@ Let's see another example:
         using namespace mp_units;
 
         // add a custom quantity type of kind isq::length
-        inline constexpr struct horizontal_length final :
+        constexpr struct horizontal_length final :
             quantity_spec<isq::length> {} horizontal_length;
 
         // add a custom derived quantity type of kind isq::area
         // with a constrained quantity equation
-        inline constexpr struct horizontal_area final :
+        constexpr struct horizontal_area final :
             quantity_spec<isq::area, horizontal_length * isq::width> {} horizontal_area;
 
         class StorageTank {
@@ -429,12 +429,12 @@ Let's see another example:
         using namespace mp_units;
 
         // add a custom quantity type of kind isq::length
-        inline constexpr struct horizontal_length final :
+        constexpr struct horizontal_length final :
             quantity_spec<isq::length> {} horizontal_length;
 
         // add a custom derived quantity type of kind isq::area
         // with a constrained quantity equation
-        inline constexpr struct horizontal_area final :
+        constexpr struct horizontal_area final :
             quantity_spec<isq::area, horizontal_length * isq::width> {} horizontal_area;
 
         class StorageTank {
diff --git a/docs/users_guide/framework_basics/systems_of_quantities.md b/docs/users_guide/framework_basics/systems_of_quantities.md
index 438de213..fb9ee547 100644
--- a/docs/users_guide/framework_basics/systems_of_quantities.md
+++ b/docs/users_guide/framework_basics/systems_of_quantities.md
@@ -148,45 +148,45 @@ For example, here is how the above quantity kind tree can be modeled in the libr
 === "C++23"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<dim_length> {} length;
-    inline constexpr struct width final : quantity_spec<length> {} width;
-    inline constexpr auto breadth = width;
-    inline constexpr struct height final : quantity_spec<length> {} height;
-    inline constexpr auto depth = height;
-    inline constexpr auto altitude = height;
-    inline constexpr struct thickness final : quantity_spec<width> {} thickness;
-    inline constexpr struct diameter final : quantity_spec<width> {} diameter;
-    inline constexpr struct radius final : quantity_spec<width> {} radius;
-    inline constexpr struct radius_of_curvature final : quantity_spec<radius> {} radius_of_curvature;
-    inline constexpr struct path_length final : quantity_spec<length> {} path_length;
-    inline constexpr auto arc_length = path_length;
-    inline constexpr struct distance final : quantity_spec<path_length> {} distance;
-    inline constexpr struct radial_distance final : quantity_spec<distance> {} radial_distance;
-    inline constexpr struct wavelength final : quantity_spec<length> {} wavelength;
-    inline constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
-    inline constexpr struct displacement final : quantity_spec<length, quantity_character::vector> {} displacement;
+    constexpr struct length final : quantity_spec<dim_length> {} length;
+    constexpr struct width final : quantity_spec<length> {} width;
+    constexpr auto breadth = width;
+    constexpr struct height final : quantity_spec<length> {} height;
+    constexpr auto depth = height;
+    constexpr auto altitude = height;
+    constexpr struct thickness final : quantity_spec<width> {} thickness;
+    constexpr struct diameter final : quantity_spec<width> {} diameter;
+    constexpr struct radius final : quantity_spec<width> {} radius;
+    constexpr struct radius_of_curvature final : quantity_spec<radius> {} radius_of_curvature;
+    constexpr struct path_length final : quantity_spec<length> {} path_length;
+    constexpr auto arc_length = path_length;
+    constexpr struct distance final : quantity_spec<path_length> {} distance;
+    constexpr struct radial_distance final : quantity_spec<distance> {} radial_distance;
+    constexpr struct wavelength final : quantity_spec<length> {} wavelength;
+    constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
+    constexpr struct displacement final : quantity_spec<length, quantity_character::vector> {} displacement;
     ```
 
 === "C++20"
 
     ```cpp
-    inline constexpr struct length final : quantity_spec<length, dim_length> {} length;
-    inline constexpr struct width final : quantity_spec<width, length> {} width;
-    inline constexpr auto breadth = width;
-    inline constexpr struct height final : quantity_spec<height, length> {} height;
-    inline constexpr auto depth = height;
-    inline constexpr auto altitude = height;
-    inline constexpr struct thickness final : quantity_spec<thickness, width> {} thickness;
-    inline constexpr struct diameter final : quantity_spec<diameter, width> {} diameter;
-    inline constexpr struct radius final : quantity_spec<radius, width> {} radius;
-    inline constexpr struct radius_of_curvature final : quantity_spec<radius_of_curvature, radius> {} radius_of_curvature;
-    inline constexpr struct path_length final : quantity_spec<path_length, length> {} path_length;
-    inline constexpr auto arc_length = path_length;
-    inline constexpr struct distance final : quantity_spec<distance, path_length> {} distance;
-    inline constexpr struct radial_distance final : quantity_spec<radial_distance, distance> {} radial_distance;
-    inline constexpr struct wavelength final : quantity_spec<wavelength, length> {} wavelength;
-    inline constexpr struct position_vector final : quantity_spec<position_vector, length, quantity_character::vector> {} position_vector;
-    inline constexpr struct displacement final : quantity_spec<displacement, length, quantity_character::vector> {} displacement;
+    constexpr struct length final : quantity_spec<length, dim_length> {} length;
+    constexpr struct width final : quantity_spec<width, length> {} width;
+    constexpr auto breadth = width;
+    constexpr struct height final : quantity_spec<height, length> {} height;
+    constexpr auto depth = height;
+    constexpr auto altitude = height;
+    constexpr struct thickness final : quantity_spec<thickness, width> {} thickness;
+    constexpr struct diameter final : quantity_spec<diameter, width> {} diameter;
+    constexpr struct radius final : quantity_spec<radius, width> {} radius;
+    constexpr struct radius_of_curvature final : quantity_spec<radius_of_curvature, radius> {} radius_of_curvature;
+    constexpr struct path_length final : quantity_spec<path_length, length> {} path_length;
+    constexpr auto arc_length = path_length;
+    constexpr struct distance final : quantity_spec<distance, path_length> {} distance;
+    constexpr struct radial_distance final : quantity_spec<radial_distance, distance> {} radial_distance;
+    constexpr struct wavelength final : quantity_spec<wavelength, length> {} wavelength;
+    constexpr struct position_vector final : quantity_spec<position_vector, length, quantity_character::vector> {} position_vector;
+    constexpr struct displacement final : quantity_spec<displacement, length, quantity_character::vector> {} displacement;
     ```
 
 === "Portable"
@@ -194,16 +194,16 @@ For example, here is how the above quantity kind tree can be modeled in the libr
     ```cpp
     QUANTITY_SPEC(length, dim_length);
     QUANTITY_SPEC(width, length);
-    inline constexpr auto breadth = width;
+    constexpr auto breadth = width;
     QUANTITY_SPEC(height, length);
-    inline constexpr auto depth = height;
-    inline constexpr auto altitude = height;
+    constexpr auto depth = height;
+    constexpr auto altitude = height;
     QUANTITY_SPEC(thickness, width);
     QUANTITY_SPEC(diameter, width);
     QUANTITY_SPEC(radius, width);
     QUANTITY_SPEC(radius_of_curvature, radius);
     QUANTITY_SPEC(path_length, length);
-    inline constexpr auto arc_length = path_length;
+    constexpr auto arc_length = path_length;
     QUANTITY_SPEC(distance, path_length);
     QUANTITY_SPEC(radial_distance, distance);
     QUANTITY_SPEC(wavelength, length);
diff --git a/docs/users_guide/framework_basics/systems_of_units.md b/docs/users_guide/framework_basics/systems_of_units.md
index df37b6bf..a5573ddc 100644
--- a/docs/users_guide/framework_basics/systems_of_units.md
+++ b/docs/users_guide/framework_basics/systems_of_units.md
@@ -26,7 +26,7 @@ this is expressed by associating a quantity kind (that we discussed in detail in
 previous chapter) with a unit that is used to express it:
 
 ```cpp
-inline constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
+constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
 ```
 
 !!! important
@@ -67,7 +67,7 @@ of a specific predefined [unit equation](../../appendix/glossary.md#unit-equatio
 For example, a unit of _power_ quantity is defined in the library as:
 
 ```cpp
-inline constexpr struct watt final : named_unit<"W", joule / second> {} watt;
+constexpr struct watt final : named_unit<"W", joule / second> {} watt;
 ```
 
 However, a _power_ quantity can be expressed in other units as well. For example,
@@ -110,8 +110,8 @@ The library allows constraining such units to work only with quantities of a spe
 the following way:
 
 ```cpp
-inline constexpr struct hertz final : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
-inline constexpr struct becquerel final : named_unit<"Bq", one / second, kind_of<isq::activity>> {} becquerel;
+constexpr struct hertz final : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
+constexpr struct becquerel final : named_unit<"Bq", one / second, kind_of<isq::activity>> {} becquerel;
 ```
 
 With the above, `hertz` can only be used with _frequencies_, while `becquerel` should only be used with
@@ -138,14 +138,14 @@ Each prefix is implemented similarly to the following:
 
 ```cpp
 template<PrefixableUnit U> struct quecto_ : prefixed_unit<"q", mag_power<10, -30>, U{}> {};
-template<PrefixableUnit auto U> inline constexpr quecto_<decltype(U)> quecto;
+template<PrefixableUnit auto U> constexpr quecto_<decltype(U)> quecto;
 ```
 
 and then a [PrefixableUnit](concepts.md#PrefixableUnit) can be prefixed in the following
 way:
 
 ```cpp
-inline constexpr auto qm = quecto<metre>;
+constexpr auto qm = quecto<metre>;
 ```
 
 The usage of `mag_power` not only enables providing support for SI prefixes, but it can also
@@ -154,7 +154,7 @@ IT industry can be implemented as:
 
 ```cpp
 template<PrefixableUnit U> struct yobi_ : prefixed_unit<"Yi", mag_power<2, 80>, U{}> {};
-template<PrefixableUnit auto U> inline constexpr yobi_<decltype(U)> yobi;
+template<PrefixableUnit auto U> constexpr yobi_<decltype(U)> yobi;
 ```
 
 ## Scaled units
@@ -168,25 +168,25 @@ be explicitly expressed with predefined SI prefixes. Those include units like mi
 electronvolt:
 
 ```cpp
-inline constexpr struct minute final : named_unit<"min", mag<60> * si::second> {} minute;
-inline constexpr struct hour final : named_unit<"h", mag<60> * minute> {} hour;
-inline constexpr struct electronvolt final : named_unit<"eV", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * si::joule> {} electronvolt;
+constexpr struct minute final : named_unit<"min", mag<60> * si::second> {} minute;
+constexpr struct hour final : named_unit<"h", mag<60> * minute> {} hour;
+constexpr struct electronvolt final : named_unit<"eV", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * si::joule> {} electronvolt;
 ```
 
 Also, units of other [systems of units](../../appendix/glossary.md#system-of-units) are often defined
 in terms of scaled versions of the SI units. For example, the international yard is defined as:
 
 ```cpp
-inline constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
+constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
 ```
 
 For some units, a magnitude might also be irrational. The best example here is a `degree` which
 is defined using a floating-point magnitude having a factor of the number π (Pi):
 
 ```cpp
-inline constexpr struct mag_pi final : magnitude<std::numbers::pi_v<long double>> {} mag_pi;
+constexpr struct mag_pi final : magnitude<std::numbers::pi_v<long double>> {} mag_pi;
 ```
 
 ```cpp
-inline constexpr struct degree final : named_unit<{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
+constexpr struct degree final : named_unit<{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
 ```
diff --git a/docs/users_guide/framework_basics/text_output.md b/docs/users_guide/framework_basics/text_output.md
index cc6c347d..0a7d7981 100644
--- a/docs/users_guide/framework_basics/text_output.md
+++ b/docs/users_guide/framework_basics/text_output.md
@@ -33,30 +33,30 @@ and units of derived quantities.
 === "Dimensions"
 
     ```cpp
-    inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
-    inline constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
-    inline constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
-    inline constexpr struct dim_electric_current final : base_dimension<"I"> {} dim_electric_current;
-    inline constexpr struct dim_thermodynamic_temperature final : base_dimension<{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
-    inline constexpr struct dim_amount_of_substance final : base_dimension<"N"> {} dim_amount_of_substance;
-    inline constexpr struct dim_luminous_intensity final : base_dimension<"J"> {} dim_luminous_intensity;
+    constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+    constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
+    constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
+    constexpr struct dim_electric_current final : base_dimension<"I"> {} dim_electric_current;
+    constexpr struct dim_thermodynamic_temperature final : base_dimension<{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
+    constexpr struct dim_amount_of_substance final : base_dimension<"N"> {} dim_amount_of_substance;
+    constexpr struct dim_luminous_intensity final : base_dimension<"J"> {} dim_luminous_intensity;
     ```
 
 === "Units"
 
     ```cpp
-    inline constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
-    inline constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
-    inline constexpr struct gram final : named_unit<"g", kind_of<isq::mass>> {} gram;
-    inline constexpr auto kilogram = kilo<gram>;
+    constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
+    constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
+    constexpr struct gram final : named_unit<"g", kind_of<isq::mass>> {} gram;
+    constexpr auto kilogram = kilo<gram>;
 
-    inline constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
-    inline constexpr struct joule final : named_unit<"J", newton * metre> {} joule;
-    inline constexpr struct watt final : named_unit<"W", joule / second> {} watt;
-    inline constexpr struct coulomb final : named_unit<"C", ampere * second> {} coulomb;
-    inline constexpr struct volt final : named_unit<"V", watt / ampere> {} volt;
-    inline constexpr struct farad final : named_unit<"F", coulomb / volt> {} farad;
-    inline constexpr struct ohm final : named_unit<{u8"Ω", "ohm"}, volt / ampere> {} ohm;
+    constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+    constexpr struct joule final : named_unit<"J", newton * metre> {} joule;
+    constexpr struct watt final : named_unit<"W", joule / second> {} watt;
+    constexpr struct coulomb final : named_unit<"C", ampere * second> {} coulomb;
+    constexpr struct volt final : named_unit<"V", watt / ampere> {} volt;
+    constexpr struct farad final : named_unit<"F", coulomb / volt> {} farad;
+    constexpr struct ohm final : named_unit<{u8"Ω", "ohm"}, volt / ampere> {} ohm;
     ```
 
 === "Prefixes"
@@ -75,13 +75,13 @@ and units of derived quantities.
 === "Constants"
 
     ```cpp
-    inline constexpr struct hyperfine_structure_transition_frequency_of_cs final : named_unit<{u8"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs;
-    inline constexpr struct speed_of_light_in_vacuum final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
-    inline constexpr struct planck_constant final : named_unit<"h", mag_ratio<662'607'015, 100'000'000> * mag_power<10, -34> * joule * second> {} planck_constant;
-    inline constexpr struct elementary_charge final : named_unit<"e", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * coulomb> {} elementary_charge;
-    inline constexpr struct boltzmann_constant final : named_unit<"k", mag_ratio<1'380'649, 1'000'000> * mag_power<10, -23> * joule / kelvin> {} boltzmann_constant;
-    inline constexpr struct avogadro_constant final : named_unit<"N_A", mag_ratio<602'214'076, 100'000'000> * mag_power<10, 23> / mole> {} avogadro_constant;
-    inline constexpr struct luminous_efficacy final : named_unit<"K_cd", mag<683> * lumen / watt> {} luminous_efficacy;
+    constexpr struct hyperfine_structure_transition_frequency_of_cs final : named_unit<{u8"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs;
+    constexpr struct speed_of_light_in_vacuum final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
+    constexpr struct planck_constant final : named_unit<"h", mag_ratio<662'607'015, 100'000'000> * mag_power<10, -34> * joule * second> {} planck_constant;
+    constexpr struct elementary_charge final : named_unit<"e", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * coulomb> {} elementary_charge;
+    constexpr struct boltzmann_constant final : named_unit<"k", mag_ratio<1'380'649, 1'000'000> * mag_power<10, -23> * joule / kelvin> {} boltzmann_constant;
+    constexpr struct avogadro_constant final : named_unit<"N_A", mag_ratio<602'214'076, 100'000'000> * mag_power<10, 23> / mole> {} avogadro_constant;
+    constexpr struct luminous_efficacy final : named_unit<"K_cd", mag<683> * lumen / watt> {} luminous_efficacy;
     ```
 
 !!! important
@@ -105,7 +105,7 @@ and units of derived quantities.
     template name to initialize it with two symbols:
 
     ```cpp
-    inline constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
+    constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
     ```
 
 
@@ -288,7 +288,7 @@ specialization for a specific unit:
 
 ```cpp
 template<>
-inline constexpr bool space_before_unit_symbol<non_si::degree> = false;
+constexpr bool space_before_unit_symbol<non_si::degree> = false;
 ```
 
 !!! note
diff --git a/docs/users_guide/framework_basics/the_affine_space.md b/docs/users_guide/framework_basics/the_affine_space.md
index 688c4379..7e760aca 100644
--- a/docs/users_guide/framework_basics/the_affine_space.md
+++ b/docs/users_guide/framework_basics/the_affine_space.md
@@ -196,7 +196,7 @@ origin.
 ![affine_space_2](affine_space_2.svg){style="width:80%;display: block;margin: 0 auto;"}
 
 ```cpp
-inline constexpr struct origin final : absolute_point_origin<isq::distance> {} origin;
+constexpr struct origin final : absolute_point_origin<isq::distance> {} origin;
 
 // quantity_point<si::metre, origin> qp1{100 * m};        // Compile-time error
 // quantity_point<si::metre, origin> qp2{delta<m>(120)};  // Compile-time error
@@ -265,8 +265,8 @@ type and unit is being used:
 ![affine_space_3](affine_space_3.svg){style="width:80%;display: block;margin: 0 auto;"}
 
 ```cpp
-inline constexpr struct origin1 final : absolute_point_origin<isq::distance> {} origin1;
-inline constexpr struct origin2 final : absolute_point_origin<isq::distance> {} origin2;
+constexpr struct origin1 final : absolute_point_origin<isq::distance> {} origin1;
+constexpr struct origin2 final : absolute_point_origin<isq::distance> {} origin2;
 
 quantity_point qp1 = origin1 + 100 * m;
 quantity_point qp2 = origin2 + 120 * m;
@@ -300,10 +300,10 @@ For such cases, relative point origins should be used:
 ![affine_space_4](affine_space_4.svg){style="width:80%;display: block;margin: 0 auto;"}
 
 ```cpp
-inline constexpr struct A final : absolute_point_origin<isq::distance> {} A;
-inline constexpr struct B final : relative_point_origin<A + 10 * m> {} B;
-inline constexpr struct C final : relative_point_origin<B + 10 * m> {} C;
-inline constexpr struct D final : relative_point_origin<A + 30 * m> {} D;
+constexpr struct A final : absolute_point_origin<isq::distance> {} A;
+constexpr struct B final : relative_point_origin<A + 10 * m> {} B;
+constexpr struct C final : relative_point_origin<B + 10 * m> {} C;
+constexpr struct D final : relative_point_origin<A + 30 * m> {} D;
 
 quantity_point qp1 = C + 100 * m;
 quantity_point qp2 = D + 120 * m;
@@ -408,17 +408,17 @@ point origins for this purpose:
 ```cpp
 namespace si {
 
-inline constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
-inline constexpr auto zeroth_kelvin = absolute_zero;
+constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
+constexpr auto zeroth_kelvin = absolute_zero;
 
-inline constexpr struct ice_point final : relative_point_origin<absolute<milli<kelvin>>(273'150)}> {} ice_point;
-inline constexpr auto zeroth_degree_Celsius = ice_point;
+constexpr struct ice_point final : relative_point_origin<absolute<milli<kelvin>>(273'150)}> {} ice_point;
+constexpr auto zeroth_degree_Celsius = ice_point;
 
 }
 
 namespace usc {
 
-inline constexpr struct zeroth_degree_Fahrenheit final :
+constexpr struct zeroth_degree_Fahrenheit final :
   relative_point_origin<absolute<mag_ratio<5, 9> * si::degree_Celsius>(-32)> {} zeroth_degree_Fahrenheit;
 
 }
@@ -442,16 +442,16 @@ definitions:
 ```cpp
 namespace si {
 
-inline constexpr struct kelvin final :
+constexpr struct kelvin final :
     named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
-inline constexpr struct degree_Celsius final :
+constexpr struct degree_Celsius final :
     named_unit<{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
 
 }
 
 namespace usc {
 
-inline constexpr struct degree_Fahrenheit final :
+constexpr struct degree_Fahrenheit final :
     named_unit<{u8"℉", "`F"}, mag_ratio<5, 9> * si::degree_Celsius,
                zeroth_degree_Fahrenheit> {} degree_Fahrenheit;
 
diff --git a/docs/users_guide/framework_basics/value_conversions.md b/docs/users_guide/framework_basics/value_conversions.md
index 1ec7e340..f22ad6aa 100644
--- a/docs/users_guide/framework_basics/value_conversions.md
+++ b/docs/users_guide/framework_basics/value_conversions.md
@@ -85,16 +85,16 @@ the `value_cast<U, Rep>(q)` which always returns the most precise result:
 === "C++23"
 
     ```cpp
-    inline constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
-    inline constexpr struct currency final : quantity_spec<dim_currency> {} currency;
+    constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
+    constexpr struct currency final : quantity_spec<dim_currency> {} currency;
 
-    inline constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
-    inline constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
+    constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
+    constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
 
     namespace unit_symbols {
 
-    inline constexpr auto USD = us_dollar;
-    inline constexpr auto USD_s = scaled_us_dollar;
+    constexpr auto USD = us_dollar;
+    constexpr auto USD_s = scaled_us_dollar;
 
     }  // namespace unit_symbols
 
@@ -105,16 +105,16 @@ the `value_cast<U, Rep>(q)` which always returns the most precise result:
 === "C++20"
 
     ```cpp
-    inline constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
-    inline constexpr struct currency final : quantity_spec<currency, dim_currency> {} currency;
+    constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
+    constexpr struct currency final : quantity_spec<currency, dim_currency> {} currency;
 
-    inline constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
-    inline constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
+    constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
+    constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
 
     namespace unit_symbols {
 
-    inline constexpr auto USD = us_dollar;
-    inline constexpr auto USD_s = scaled_us_dollar;
+    constexpr auto USD = us_dollar;
+    constexpr auto USD_s = scaled_us_dollar;
 
     }  // namespace unit_symbols
 
@@ -125,16 +125,16 @@ the `value_cast<U, Rep>(q)` which always returns the most precise result:
 === "Portable"
 
     ```cpp
-    inline constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
+    constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
     QUANTITY_SPEC(currency, dim_currency);
 
-    inline constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
-    inline constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
+    constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
+    constexpr struct scaled_us_dollar final : named_unit<"USD_s", mag_power<10, -8> * us_dollar> {} scaled_us_dollar;
 
     namespace unit_symbols {
 
-    inline constexpr auto USD = us_dollar;
-    inline constexpr auto USD_s = scaled_us_dollar;
+    constexpr auto USD = us_dollar;
+    constexpr auto USD_s = scaled_us_dollar;
 
     }  // namespace unit_symbols
 
diff --git a/docs/users_guide/use_cases/interoperability_with_other_libraries.md b/docs/users_guide/use_cases/interoperability_with_other_libraries.md
index 07da96af..b449b02f 100644
--- a/docs/users_guide/use_cases/interoperability_with_other_libraries.md
+++ b/docs/users_guide/use_cases/interoperability_with_other_libraries.md
@@ -249,8 +249,8 @@ include the _mp-units/systems/si/chrono.h_ file to benefit from it. This file pr
     to the `std::chrono` abstractions:
 
     ```cpp
-    inline constexpr struct ts_origin final : relative_point_origin<chrono_point_origin<system_clock> + 1 * h> {} ts_origin;
-    inline constexpr struct my_origin final : absolute_point_origin<isq::time> {} my_origin;
+    constexpr struct ts_origin final : relative_point_origin<chrono_point_origin<system_clock> + 1 * h> {} ts_origin;
+    constexpr struct my_origin final : absolute_point_origin<isq::time> {} my_origin;
 
     quantity_point qp1 = sys_seconds{1s};
     auto tp1 = to_chrono_time_point(qp1);  // OK
diff --git a/docs/users_guide/use_cases/wide_compatibility.md b/docs/users_guide/use_cases/wide_compatibility.md
index b3420d12..22c968c1 100644
--- a/docs/users_guide/use_cases/wide_compatibility.md
+++ b/docs/users_guide/use_cases/wide_compatibility.md
@@ -29,7 +29,7 @@ your code using **mp-units**:
 
     // ...
 
-    inline constexpr struct horizontal_length final : quantity_spec<isq::length> {} horizontal_length;
+    constexpr struct horizontal_length final : quantity_spec<isq::length> {} horizontal_length;
 
     // ...
 
@@ -45,7 +45,7 @@ your code using **mp-units**:
 
     // ...
 
-    inline constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
+    constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
 
     // ...
 
@@ -65,7 +65,7 @@ your code using **mp-units**:
 
     // ...
 
-    inline constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
+    constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
 
     // ...
 
@@ -85,7 +85,7 @@ your code using **mp-units**:
 
     // ...
 
-    inline constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
+    constexpr struct horizontal_length final : quantity_spec<horizontal_length, isq::length> {} horizontal_length;
 
     // ...
 
diff --git a/example/currency.cpp b/example/currency.cpp
index 6f280659..fcc0e0d5 100644
--- a/example/currency.cpp
+++ b/example/currency.cpp
@@ -40,22 +40,22 @@ import mp_units.core;
 using namespace mp_units;
 
 // clang-format off
-inline constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
+constexpr struct dim_currency final : base_dimension<"$"> {} dim_currency;
 
 QUANTITY_SPEC(currency, dim_currency);
 
-inline constexpr struct euro final : named_unit<"EUR", kind_of<currency>> {} euro;
-inline constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
-inline constexpr struct great_british_pound final : named_unit<"GBP", kind_of<currency>> {} great_british_pound;
-inline constexpr struct japanese_jen final : named_unit<"JPY", kind_of<currency>> {} japanese_jen;
+constexpr struct euro final : named_unit<"EUR", kind_of<currency>> {} euro;
+constexpr struct us_dollar final : named_unit<"USD", kind_of<currency>> {} us_dollar;
+constexpr struct great_british_pound final : named_unit<"GBP", kind_of<currency>> {} great_british_pound;
+constexpr struct japanese_jen final : named_unit<"JPY", kind_of<currency>> {} japanese_jen;
 // clang-format on
 
 namespace unit_symbols {
 
-inline constexpr auto EUR = euro;
-inline constexpr auto USD = us_dollar;
-inline constexpr auto GBP = great_british_pound;
-inline constexpr auto JPY = japanese_jen;
+constexpr auto EUR = euro;
+constexpr auto USD = us_dollar;
+constexpr auto GBP = great_british_pound;
+constexpr auto JPY = japanese_jen;
 
 }  // namespace unit_symbols
 
diff --git a/example/include/geographic.h b/example/include/geographic.h
index ba26b3f1..9cbaaee1 100644
--- a/example/include/geographic.h
+++ b/example/include/geographic.h
@@ -44,7 +44,7 @@ import mp_units;
 
 namespace geographic {
 
-inline constexpr struct mean_sea_level final : mp_units::absolute_point_origin<mp_units::isq::altitude> {
+constexpr struct mean_sea_level final : mp_units::absolute_point_origin<mp_units::isq::altitude> {
 } mean_sea_level;
 
 using msl_altitude = mp_units::quantity_point<mp_units::isq::altitude[mp_units::si::metre], mean_sea_level>;
@@ -72,9 +72,9 @@ struct MP_UNITS_STD_FMT::formatter<geographic::msl_altitude, Char> :
 
 namespace geographic {
 
-inline constexpr struct equator final : mp_units::absolute_point_origin<mp_units::isq::angular_measure> {
+constexpr struct equator final : mp_units::absolute_point_origin<mp_units::isq::angular_measure> {
 } equator;
-inline constexpr struct prime_meridian final : mp_units::absolute_point_origin<mp_units::isq::angular_measure> {
+constexpr struct prime_meridian final : mp_units::absolute_point_origin<mp_units::isq::angular_measure> {
 } prime_meridian;
 
 
diff --git a/example/include/ranged_representation.h b/example/include/ranged_representation.h
index 67557624..335f22dd 100644
--- a/example/include/ranged_representation.h
+++ b/example/include/ranged_representation.h
@@ -42,7 +42,7 @@ import mp_units.core;
 
 template<std::movable T, MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Min,
          MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Max>
-inline constexpr auto is_in_range = [](const auto& v) { return std::clamp(v, T{Min}, T{Max}) == v; };
+constexpr auto is_in_range = [](const auto& v) { return std::clamp(v, T{Min}, T{Max}) == v; };
 
 template<std::movable T, MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Min,
          MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Max>
@@ -63,10 +63,10 @@ public:
 };
 
 template<typename T, auto Min, auto Max>
-inline constexpr bool mp_units::is_scalar<ranged_representation<T, Min, Max>> = mp_units::is_scalar<T>;
+constexpr bool mp_units::is_scalar<ranged_representation<T, Min, Max>> = mp_units::is_scalar<T>;
 
 template<typename T, auto Min, auto Max>
-inline constexpr bool mp_units::treat_as_floating_point<ranged_representation<T, Min, Max>> =
+constexpr bool mp_units::treat_as_floating_point<ranged_representation<T, Min, Max>> =
   mp_units::treat_as_floating_point<T>;
 
 template<typename T, auto Min, auto Max, typename Char>
diff --git a/example/include/validated_type.h b/example/include/validated_type.h
index efc1d946..0150c118 100644
--- a/example/include/validated_type.h
+++ b/example/include/validated_type.h
@@ -40,7 +40,7 @@ import mp_units.core;
 #include <mp-units/framework/customization_points.h>
 #endif
 
-inline constexpr struct validated_tag {
+constexpr struct validated_tag {
 } validated;
 
 template<std::movable T, std::predicate<T> Validator>
@@ -114,11 +114,10 @@ public:
 };
 
 template<typename T, typename Validator>
-inline constexpr bool mp_units::is_scalar<validated_type<T, Validator>> = mp_units::is_scalar<T>;
+constexpr bool mp_units::is_scalar<validated_type<T, Validator>> = mp_units::is_scalar<T>;
 
 template<typename T, typename Validator>
-inline constexpr bool mp_units::treat_as_floating_point<validated_type<T, Validator>> =
-  mp_units::treat_as_floating_point<T>;
+constexpr bool mp_units::treat_as_floating_point<validated_type<T, Validator>> = mp_units::treat_as_floating_point<T>;
 
 
 template<typename CharT, typename Traits, typename T, typename Validator>
diff --git a/example/kalman_filter/kalman.h b/example/kalman_filter/kalman.h
index 6e629477..90d0d506 100644
--- a/example/kalman_filter/kalman.h
+++ b/example/kalman_filter/kalman.h
@@ -47,13 +47,13 @@ namespace kalman {
 namespace detail {
 
 template<mp_units::Dimension auto... Ds>
-inline constexpr bool are_time_derivatives = false;
+constexpr bool are_time_derivatives = false;
 
 template<mp_units::Dimension auto D>
-inline constexpr bool are_time_derivatives<D> = true;
+constexpr bool are_time_derivatives<D> = true;
 
 template<mp_units::Dimension auto D1, mp_units::Dimension auto D2, mp_units::Dimension auto... Ds>
-inline constexpr bool are_time_derivatives<D1, D2, Ds...> =
+constexpr bool are_time_derivatives<D1, D2, Ds...> =
   (D1 / D2 == mp_units::isq::dim_time) && are_time_derivatives<D2, Ds...>;
 
 }  // namespace detail
diff --git a/example/kalman_filter/kalman_filter-example_2.cpp b/example/kalman_filter/kalman_filter-example_2.cpp
index daec350c..b03f8724 100644
--- a/example/kalman_filter/kalman_filter-example_2.cpp
+++ b/example/kalman_filter/kalman_filter-example_2.cpp
@@ -40,7 +40,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 using namespace mp_units;
 
diff --git a/example/kalman_filter/kalman_filter-example_3.cpp b/example/kalman_filter/kalman_filter-example_3.cpp
index 2e51cba1..9c2ca7d4 100644
--- a/example/kalman_filter/kalman_filter-example_3.cpp
+++ b/example/kalman_filter/kalman_filter-example_3.cpp
@@ -40,7 +40,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 using namespace mp_units;
 
diff --git a/example/kalman_filter/kalman_filter-example_4.cpp b/example/kalman_filter/kalman_filter-example_4.cpp
index f4df77a5..20813ad8 100644
--- a/example/kalman_filter/kalman_filter-example_4.cpp
+++ b/example/kalman_filter/kalman_filter-example_4.cpp
@@ -40,7 +40,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 using namespace mp_units;
 
diff --git a/example/measurement.cpp b/example/measurement.cpp
index 5e1e5419..d61c8d2e 100644
--- a/example/measurement.cpp
+++ b/example/measurement.cpp
@@ -132,12 +132,12 @@ private:
 }  // namespace
 
 template<class T>
-inline constexpr bool mp_units::treat_as_floating_point<measurement<T>> = mp_units::treat_as_floating_point<T>;
+constexpr bool mp_units::treat_as_floating_point<measurement<T>> = mp_units::treat_as_floating_point<T>;
 
 template<class T>
-inline constexpr bool mp_units::is_scalar<measurement<T>> = true;
+constexpr bool mp_units::is_scalar<measurement<T>> = true;
 template<class T>
-inline constexpr bool mp_units::is_vector<measurement<T>> = true;
+constexpr bool mp_units::is_vector<measurement<T>> = true;
 
 static_assert(mp_units::RepresentationOf<measurement<double>, mp_units::quantity_character::scalar>);
 
diff --git a/example/si_constants.cpp b/example/si_constants.cpp
index 022003f9..e09588c4 100644
--- a/example/si_constants.cpp
+++ b/example/si_constants.cpp
@@ -41,7 +41,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 int main()
 {
diff --git a/example/storage_tank.cpp b/example/storage_tank.cpp
index ad9f7580..2bb4f237 100644
--- a/example/storage_tank.cpp
+++ b/example/storage_tank.cpp
@@ -44,7 +44,7 @@ import mp_units;
 // types instead of requiring the usage of Linear Algebra library for this simple example
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
@@ -58,8 +58,8 @@ QUANTITY_SPEC(horizontal_length, isq::length);
 // with a constrained quantity equation
 QUANTITY_SPEC(horizontal_area, isq::area, horizontal_length* isq::width);
 
-inline constexpr auto g = 1 * si::standard_gravity;
-inline constexpr auto air_density = isq::mass_density(1.225 * kg / m3);
+constexpr auto g = 1 * si::standard_gravity;
+constexpr auto air_density = isq::mass_density(1.225 * kg / m3);
 
 class StorageTank {
   quantity<horizontal_area[m2]> base_;
diff --git a/example/strong_angular_quantities.cpp b/example/strong_angular_quantities.cpp
index 6487860d..9c03b36c 100644
--- a/example/strong_angular_quantities.cpp
+++ b/example/strong_angular_quantities.cpp
@@ -35,7 +35,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 int main()
 {
diff --git a/example/total_energy.cpp b/example/total_energy.cpp
index bcd149d6..75416bb7 100644
--- a/example/total_energy.cpp
+++ b/example/total_energy.cpp
@@ -39,7 +39,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
diff --git a/example/unmanned_aerial_vehicle.cpp b/example/unmanned_aerial_vehicle.cpp
index 3e26ac08..2551110d 100644
--- a/example/unmanned_aerial_vehicle.cpp
+++ b/example/unmanned_aerial_vehicle.cpp
@@ -53,7 +53,7 @@ struct height_above_ellipsoid_t final : absolute_point_origin<isq::altitude> {
   static constexpr earth_gravity_model egm = M;
 };
 template<earth_gravity_model M>
-inline constexpr height_above_ellipsoid_t<M> height_above_ellipsoid;  // NOLINT(google-readability-casting)
+constexpr height_above_ellipsoid_t<M> height_above_ellipsoid;  // NOLINT(google-readability-casting)
 
 template<earth_gravity_model M>
 using hae_altitude = quantity_point<isq::altitude[si::metre], height_above_ellipsoid<M>>;
@@ -119,7 +119,7 @@ hae_altitude<M> to_hae(msl_altitude msl, position<long double> pos)
 // **** HAL ****
 
 // clang-format off
-inline constexpr struct height_above_launch final : absolute_point_origin<isq::altitude> {} height_above_launch;
+constexpr struct height_above_launch final : absolute_point_origin<isq::altitude> {} height_above_launch;
 // clang-format on
 
 using hal_altitude = quantity_point<isq::altitude[si::metre], height_above_launch>;
diff --git a/src/core/include/mp-units/bits/fmt.h b/src/core/include/mp-units/bits/fmt.h
index c4572a9c..9889b971 100644
--- a/src/core/include/mp-units/bits/fmt.h
+++ b/src/core/include/mp-units/bits/fmt.h
@@ -122,7 +122,7 @@ public:
 MP_UNITS_EXPORT_END
 
 template<typename T>
-inline constexpr bool is_integer =
+constexpr bool is_integer =
   std::is_integral_v<T> && !std::is_same_v<T, bool> && !std::is_same_v<T, char> && !std::is_same_v<T, wchar_t>;
 
 // Converts a character to ASCII. Returns a number > 127 on conversion failure.
diff --git a/src/core/include/mp-units/bits/hacks.h b/src/core/include/mp-units/bits/hacks.h
index 5030debb..2c66f296 100644
--- a/src/core/include/mp-units/bits/hacks.h
+++ b/src/core/include/mp-units/bits/hacks.h
@@ -104,7 +104,7 @@ namespace std {
 struct from_range_t {
   explicit from_range_t() = default;
 };
-inline constexpr from_range_t from_range{};
+constexpr from_range_t from_range{};
 
 }  // namespace std
 
diff --git a/src/core/include/mp-units/bits/text_tools.h b/src/core/include/mp-units/bits/text_tools.h
index a01eb4a7..123ad858 100644
--- a/src/core/include/mp-units/bits/text_tools.h
+++ b/src/core/include/mp-units/bits/text_tools.h
@@ -40,32 +40,32 @@ namespace mp_units::detail {
 
 template<std::intmax_t Value>
   requires(0 <= Value) && (Value < 10)
-inline constexpr basic_fixed_string superscript_number = u8"";
+constexpr basic_fixed_string superscript_number = u8"";
 
 template<>
-inline constexpr basic_fixed_string superscript_number<0> = u8"\u2070";
+constexpr basic_fixed_string superscript_number<0> = u8"\u2070";
 template<>
-inline constexpr basic_fixed_string superscript_number<1> = u8"\u00b9";
+constexpr basic_fixed_string superscript_number<1> = u8"\u00b9";
 template<>
-inline constexpr basic_fixed_string superscript_number<2> = u8"\u00b2";
+constexpr basic_fixed_string superscript_number<2> = u8"\u00b2";
 template<>
-inline constexpr basic_fixed_string superscript_number<3> = u8"\u00b3";
+constexpr basic_fixed_string superscript_number<3> = u8"\u00b3";
 template<>
-inline constexpr basic_fixed_string superscript_number<4> = u8"\u2074";
+constexpr basic_fixed_string superscript_number<4> = u8"\u2074";
 template<>
-inline constexpr basic_fixed_string superscript_number<5> = u8"\u2075";
+constexpr basic_fixed_string superscript_number<5> = u8"\u2075";
 template<>
-inline constexpr basic_fixed_string superscript_number<6> = u8"\u2076";
+constexpr basic_fixed_string superscript_number<6> = u8"\u2076";
 template<>
-inline constexpr basic_fixed_string superscript_number<7> = u8"\u2077";
+constexpr basic_fixed_string superscript_number<7> = u8"\u2077";
 template<>
-inline constexpr basic_fixed_string superscript_number<8> = u8"\u2078";
+constexpr basic_fixed_string superscript_number<8> = u8"\u2078";
 template<>
-inline constexpr basic_fixed_string superscript_number<9> = u8"\u2079";
+constexpr basic_fixed_string superscript_number<9> = u8"\u2079";
 
-inline constexpr symbol_text superscript_minus(u8"\u207b", "-");
+constexpr symbol_text superscript_minus(u8"\u207b", "-");
 
-inline constexpr symbol_text superscript_prefix(u8"", "^");
+constexpr symbol_text superscript_prefix(u8"", "^");
 
 template<std::intmax_t Value>
 [[nodiscard]] consteval auto superscript_helper()
diff --git a/src/core/include/mp-units/bits/type_list.h b/src/core/include/mp-units/bits/type_list.h
index 203326c6..913a7a94 100644
--- a/src/core/include/mp-units/bits/type_list.h
+++ b/src/core/include/mp-units/bits/type_list.h
@@ -40,10 +40,10 @@ MP_UNITS_DIAGNOSTIC_IGNORE_EXPR_ALWAYS_TF
 namespace mp_units::detail {
 
 template<typename T>
-inline constexpr bool is_type_list = false;
+constexpr bool is_type_list = false;
 
 template<template<typename...> typename T, typename... Types>
-inline constexpr bool is_type_list<T<Types...>> = true;
+constexpr bool is_type_list<T<Types...>> = true;
 
 template<typename T>
 concept TypeList = is_type_list<T>;
@@ -56,7 +56,7 @@ template<template<typename...> typename List, typename... Types>
 struct type_list_size_impl<List<Types...>> : std::integral_constant<std::size_t, sizeof...(Types)> {};
 
 template<TypeList List>
-inline constexpr std::size_t type_list_size = type_list_size_impl<List>::value;
+constexpr std::size_t type_list_size = type_list_size_impl<List>::value;
 
 // map
 template<typename T, template<typename...> typename To>
diff --git a/src/core/include/mp-units/compat_macros.h b/src/core/include/mp-units/compat_macros.h
index 4add3e12..f221bbbf 100644
--- a/src/core/include/mp-units/compat_macros.h
+++ b/src/core/include/mp-units/compat_macros.h
@@ -28,14 +28,14 @@
 
 #if MP_UNITS_API_NO_CRTP
 
-#define QUANTITY_SPEC(name, ...)                                                \
-  inline constexpr struct name final : ::mp_units::quantity_spec<__VA_ARGS__> { \
+#define QUANTITY_SPEC(name, ...)                                         \
+  constexpr struct name final : ::mp_units::quantity_spec<__VA_ARGS__> { \
   } name
 
 #else
 
-#define QUANTITY_SPEC(name, ...)                                                      \
-  inline constexpr struct name final : ::mp_units::quantity_spec<name, __VA_ARGS__> { \
+#define QUANTITY_SPEC(name, ...)                                               \
+  constexpr struct name final : ::mp_units::quantity_spec<name, __VA_ARGS__> { \
   } name
 
 #endif
diff --git a/src/core/include/mp-units/ext/type_traits.h b/src/core/include/mp-units/ext/type_traits.h
index 62e39f09..11b2b97b 100644
--- a/src/core/include/mp-units/ext/type_traits.h
+++ b/src/core/include/mp-units/ext/type_traits.h
@@ -60,26 +60,26 @@ using conditional = MP_UNITS_TYPENAME detail::conditional_impl<B>::template type
 
 // is_same
 template<class T, class U>
-inline constexpr bool is_same_v = false;
+constexpr bool is_same_v = false;
 
 template<class T>
-inline constexpr bool is_same_v<T, T> = true;
+constexpr bool is_same_v<T, T> = true;
 
 template<class T, class U>
 using is_same = std::bool_constant<is_same_v<T, U>>;
 
 // is_specialization_of
 template<typename T, template<typename...> typename Type>
-inline constexpr bool is_specialization_of = false;
+constexpr bool is_specialization_of = false;
 
 template<typename... Params, template<typename...> typename Type>
-inline constexpr bool is_specialization_of<Type<Params...>, Type> = true;
+constexpr bool is_specialization_of<Type<Params...>, Type> = true;
 
 template<typename T, template<auto...> typename Type>
-inline constexpr bool is_specialization_of_v = false;
+constexpr bool is_specialization_of_v = false;
 
 template<auto... Params, template<auto...> typename Type>
-inline constexpr bool is_specialization_of_v<Type<Params...>, Type> = true;
+constexpr bool is_specialization_of_v<Type<Params...>, Type> = true;
 
 MP_UNITS_EXPORT_END
 
@@ -92,8 +92,7 @@ void to_base_specialization_of(const volatile Type<Params...>*);
 }  // namespace detail
 
 template<typename T, template<typename...> typename Type>
-inline constexpr bool is_derived_from_specialization_of =
-  requires(T* t) { detail::to_base_specialization_of<Type>(t); };
+constexpr bool is_derived_from_specialization_of = requires(T* t) { detail::to_base_specialization_of<Type>(t); };
 
 namespace detail {
 
diff --git a/src/core/include/mp-units/framework/construction_helpers.h b/src/core/include/mp-units/framework/construction_helpers.h
index 6e20ebcc..3ad048d8 100644
--- a/src/core/include/mp-units/framework/construction_helpers.h
+++ b/src/core/include/mp-units/framework/construction_helpers.h
@@ -61,10 +61,10 @@ struct absolute_ {
 MP_UNITS_EXPORT_BEGIN
 
 template<Reference auto R>
-inline constexpr delta_<MP_UNITS_REMOVE_CONST(decltype(R))> delta{};
+constexpr delta_<MP_UNITS_REMOVE_CONST(decltype(R))> delta{};
 
 template<Reference auto R>
-inline constexpr absolute_<MP_UNITS_REMOVE_CONST(decltype(R))> absolute{};
+constexpr absolute_<MP_UNITS_REMOVE_CONST(decltype(R))> absolute{};
 
 MP_UNITS_EXPORT_END
 
diff --git a/src/core/include/mp-units/framework/customization_points.h b/src/core/include/mp-units/framework/customization_points.h
index 15fbf807..8d7add3f 100644
--- a/src/core/include/mp-units/framework/customization_points.h
+++ b/src/core/include/mp-units/framework/customization_points.h
@@ -50,11 +50,11 @@ MP_UNITS_EXPORT_BEGIN
  * @tparam Rep a representation type for which a type trait is defined
  */
 template<typename Rep>
-inline constexpr bool treat_as_floating_point = std::is_floating_point_v<Rep>;
+constexpr bool treat_as_floating_point = std::is_floating_point_v<Rep>;
 
 template<typename Rep>
   requires requires { typename wrapped_type_t<Rep>; }
-inline constexpr bool treat_as_floating_point<Rep> = treat_as_floating_point<wrapped_type_t<Rep>>;
+constexpr bool treat_as_floating_point<Rep> = treat_as_floating_point<wrapped_type_t<Rep>>;
 
 /**
  * @brief Specifies a type to have a scalar character
@@ -62,7 +62,7 @@ inline constexpr bool treat_as_floating_point<Rep> = treat_as_floating_point<wra
  * A scalar is a physical quantity that has magnitude but no direction.
  */
 template<typename Rep>
-inline constexpr bool is_scalar = std::is_floating_point_v<Rep> || (std::is_integral_v<Rep> && !is_same_v<Rep, bool>);
+constexpr bool is_scalar = std::is_floating_point_v<Rep> || (std::is_integral_v<Rep> && !is_same_v<Rep, bool>);
 
 /**
  * @brief Specifies a type to have a vector character
@@ -76,11 +76,11 @@ inline constexpr bool is_scalar = std::is_floating_point_v<Rep> || (std::is_inte
  * @code{.cpp}
  * template<class T>
  *   requires mp_units::is_scalar<T>
- * inline constexpr bool mp_units::is_vector<T> = true;
+ * constexpr bool mp_units::is_vector<T> = true;
  * @endcode
  */
 template<typename Rep>
-inline constexpr bool is_vector = false;
+constexpr bool is_vector = false;
 
 /**
  * @brief Specifies a type to have a tensor character
@@ -91,7 +91,7 @@ inline constexpr bool is_vector = false;
  * Similarly to `is_vector` a partial specialization is needed in such cases.
  */
 template<typename Rep>
-inline constexpr bool is_tensor = false;
+constexpr bool is_tensor = false;
 
 /**
  * @brief A type trait that defines zero, one, min, and max for a representation type
diff --git a/src/core/include/mp-units/framework/dimension.h b/src/core/include/mp-units/framework/dimension.h
index 6b2cb360..71b63036 100644
--- a/src/core/include/mp-units/framework/dimension.h
+++ b/src/core/include/mp-units/framework/dimension.h
@@ -115,9 +115,9 @@ struct dimension_interface {
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
- * inline constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
- * inline constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
+ * constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+ * constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
+ * constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -184,9 +184,7 @@ struct derived_dimension final : detail::dimension_interface, detail::derived_di
  * dimensions are zero. It is a dimension of a quantity of dimension one also known as
  * "dimensionless".
  */
-MP_UNITS_EXPORT inline constexpr struct dimension_one final :
-    detail::dimension_interface,
-    detail::derived_dimension_impl<> {
+MP_UNITS_EXPORT constexpr struct dimension_one final : detail::dimension_interface, detail::derived_dimension_impl<> {
 } dimension_one;
 
 namespace detail {
diff --git a/src/core/include/mp-units/framework/dimension_concepts.h b/src/core/include/mp-units/framework/dimension_concepts.h
index 7517ea7f..9bf7b3b1 100644
--- a/src/core/include/mp-units/framework/dimension_concepts.h
+++ b/src/core/include/mp-units/framework/dimension_concepts.h
@@ -53,7 +53,7 @@ template<symbol_text Symbol>
 void to_base_specialization_of_base_dimension(const volatile base_dimension<Symbol>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_base_dimension =
+constexpr bool is_derived_from_specialization_of_base_dimension =
   requires(T* t) { to_base_specialization_of_base_dimension(t); };
 
 /**
@@ -68,16 +68,16 @@ template<typename T>
 struct is_dimension_one : std::false_type {};
 
 template<typename T>
-inline constexpr bool is_power_of_dim = requires {
+constexpr bool is_power_of_dim = requires {
   requires is_specialization_of_power<T> &&
              (BaseDimension<typename T::factor> || is_dimension_one<typename T::factor>::value);
 };
 
 template<typename T>
-inline constexpr bool is_per_of_dims = false;
+constexpr bool is_per_of_dims = false;
 
 template<typename... Ts>
-inline constexpr bool is_per_of_dims<per<Ts...>> =
+constexpr bool is_per_of_dims<per<Ts...>> =
   (... && (BaseDimension<Ts> || is_dimension_one<Ts>::value || is_power_of_dim<Ts>));
 
 template<typename T>
diff --git a/src/core/include/mp-units/framework/expression_template.h b/src/core/include/mp-units/framework/expression_template.h
index 72a2db0e..51522f58 100644
--- a/src/core/include/mp-units/framework/expression_template.h
+++ b/src/core/include/mp-units/framework/expression_template.h
@@ -57,37 +57,37 @@ struct per {};
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_specialization_of_per = false;
+constexpr bool is_specialization_of_per = false;
 
 template<typename... Ts>
-inline constexpr bool is_specialization_of_per<per<Ts...>> = true;
+constexpr bool is_specialization_of_per<per<Ts...>> = true;
 
 template<int Num, int... Den>
-inline constexpr bool valid_ratio = true;
+constexpr bool valid_ratio = true;
 
 template<int... Den>
-inline constexpr bool valid_ratio<0, Den...> = false;
+constexpr bool valid_ratio<0, Den...> = false;
 
 template<int Num>
-inline constexpr bool valid_ratio<Num, 0> = false;
+constexpr bool valid_ratio<Num, 0> = false;
 
 template<>
-inline constexpr bool valid_ratio<0, 0> = false;
+constexpr bool valid_ratio<0, 0> = false;
 
 template<int Num, int... Den>
-inline constexpr bool positive_ratio = gt_zero<Num>;
+constexpr bool positive_ratio = gt_zero<Num>;
 
 template<int Num, int Den>
-inline constexpr bool positive_ratio<Num, Den> = gt_zero<Num * Den>;
+constexpr bool positive_ratio<Num, Den> = gt_zero<Num * Den>;
 
 template<int Num, int... Den>
-inline constexpr bool ratio_one = false;
+constexpr bool ratio_one = false;
 
 template<>
-inline constexpr bool ratio_one<1> = true;
+constexpr bool ratio_one<1> = true;
 
 template<int N>
-inline constexpr bool ratio_one<N, N> = true;
+constexpr bool ratio_one<N, N> = true;
 
 }  // namespace detail
 
@@ -127,10 +127,10 @@ using expr_type = MP_UNITS_TYPENAME detail::expr_type_impl<T>::type;
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_specialization_of_power = false;
+constexpr bool is_specialization_of_power = false;
 
 template<typename F, int... Ints>
-inline constexpr bool is_specialization_of_power<power<F, Ints...>> = true;
+constexpr bool is_specialization_of_power<power<F, Ints...>> = true;
 
 template<typename T, ratio R>
 consteval auto power_or_T_impl()
@@ -509,10 +509,10 @@ concept expr_type_projectable = (requires { typename Proj<T>; } ||
                                  (is_specialization_of_power<T> && requires { typename Proj<typename T::factor>; }));
 
 template<typename T, template<typename> typename Proj>
-inline constexpr bool expr_projectable_impl = false;
+constexpr bool expr_projectable_impl = false;
 
 template<typename... Ts, template<typename> typename Proj>
-inline constexpr bool expr_projectable_impl<type_list<Ts...>, Proj> = (... && expr_type_projectable<Ts, Proj>);
+constexpr bool expr_projectable_impl<type_list<Ts...>, Proj> = (... && expr_type_projectable<Ts, Proj>);
 
 template<typename T, template<typename> typename Proj>
 concept expr_projectable = requires {
diff --git a/src/core/include/mp-units/framework/magnitude.h b/src/core/include/mp-units/framework/magnitude.h
index d1632528..84312fd3 100644
--- a/src/core/include/mp-units/framework/magnitude.h
+++ b/src/core/include/mp-units/framework/magnitude.h
@@ -59,10 +59,10 @@ using factorizer = wheel_factorizer<4>;
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_magnitude = false;
+constexpr bool is_magnitude = false;
 
 template<typename T>
-inline constexpr bool is_specialization_of_magnitude = false;
+constexpr bool is_specialization_of_magnitude = false;
 
 }  // namespace detail
 
@@ -87,7 +87,7 @@ concept Magnitude = detail::is_magnitude<T>;
 // void to_base_specialization_of_constant(const volatile constant<V>*);
 
 // template<typename T>
-// inline constexpr bool is_derived_from_specialization_of_constant =
+// constexpr bool is_derived_from_specialization_of_constant =
 //   requires(T * t) { to_base_specialization_of_constant(t); };
 
 // }  // namespace detail
@@ -142,7 +142,7 @@ concept Magnitude = detail::is_magnitude<T>;
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_named_magnitude = Magnitude<T> && !detail::is_specialization_of_magnitude<T>;
+constexpr bool is_named_magnitude = Magnitude<T> && !detail::is_specialization_of_magnitude<T>;
 
 }
 
@@ -178,10 +178,10 @@ struct power_v {
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_specialization_of_power_v = false;
+constexpr bool is_specialization_of_power_v = false;
 
 template<auto V, int... Ints>
-inline constexpr bool is_specialization_of_power_v<power_v<V, Ints...>> = true;
+constexpr bool is_specialization_of_power_v<power_v<V, Ints...>> = true;
 
 }  // namespace detail
 
@@ -572,13 +572,13 @@ namespace detail {
 // }
 
 // template<MagnitudeSpec auto... Elements>
-// inline constexpr bool all_elements_valid = (is_valid_element(Elements) && ...);
+// constexpr bool all_elements_valid = (is_valid_element(Elements) && ...);
 
 // template<MagnitudeSpec auto... Elements>
-// inline constexpr bool all_elements_in_order = strictly_increasing(get_base_value(Elements)...);
+// constexpr bool all_elements_in_order = strictly_increasing(get_base_value(Elements)...);
 
 // template<MagnitudeSpec auto... Elements>
-// inline constexpr bool is_element_pack_valid = all_elements_valid<Elements...> && all_elements_in_order<Elements...>;
+// constexpr bool is_element_pack_valid = all_elements_valid<Elements...> && all_elements_in_order<Elements...>;
 
 [[nodiscard]] consteval bool is_rational(MagnitudeSpec auto element)
 {
@@ -707,15 +707,14 @@ template<auto... Ms>
 void to_base_specialization_of_magnitude(const volatile magnitude<Ms...>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_magnitude =
-  requires(T* t) { to_base_specialization_of_magnitude(t); };
+constexpr bool is_derived_from_specialization_of_magnitude = requires(T* t) { to_base_specialization_of_magnitude(t); };
 
 template<typename T>
   requires is_derived_from_specialization_of_magnitude<T>
-inline constexpr bool is_magnitude<T> = true;
+constexpr bool is_magnitude<T> = true;
 
 template<auto... Ms>
-inline constexpr bool is_specialization_of_magnitude<magnitude<Ms...>> = true;
+constexpr bool is_specialization_of_magnitude<magnitude<Ms...>> = true;
 
 }  // namespace detail
 
@@ -726,12 +725,12 @@ MP_UNITS_EXPORT_BEGIN
  */
 #if MP_UNITS_COMP_CLANG
 
-inline constexpr struct mag_pi : magnitude<mag_value{std::numbers::pi_v<long double>}> {
+constexpr struct mag_pi : magnitude<mag_value{std::numbers::pi_v<long double>}> {
 } mag_pi;
 
 #else
 
-inline constexpr struct mag_pi : magnitude<std::numbers::pi_v<long double>> {
+constexpr struct mag_pi : magnitude<std::numbers::pi_v<long double>> {
 } mag_pi;
 
 #endif
@@ -882,7 +881,7 @@ using common_magnitude_type = decltype(common_magnitude_type_impl(M));
 //
 // WARNING:  The program behaviour will be undefined if you provide a wrong answer, so check your math!
 MP_UNITS_EXPORT template<std::intmax_t N>
-inline constexpr std::optional<std::intmax_t> known_first_factor = std::nullopt;
+constexpr std::optional<std::intmax_t> known_first_factor = std::nullopt;
 
 namespace detail {
 
@@ -915,7 +914,7 @@ struct prime_factorization<1> {
 };
 
 template<std::intmax_t N>
-inline constexpr auto prime_factorization_v = prime_factorization<N>::value;
+constexpr auto prime_factorization_v = prime_factorization<N>::value;
 
 }  // namespace detail
 
@@ -927,18 +926,18 @@ inline constexpr auto prime_factorization_v = prime_factorization<N>::value;
  */
 MP_UNITS_EXPORT template<std::intmax_t V>
   requires detail::gt_zero<V>
-inline constexpr Magnitude auto mag = detail::prime_factorization_v<V>;
+constexpr Magnitude auto mag = detail::prime_factorization_v<V>;
 
 MP_UNITS_EXPORT template<std::intmax_t N, std::intmax_t D>
   requires detail::gt_zero<N>
-inline constexpr Magnitude auto mag_ratio = detail::prime_factorization_v<N> / detail::prime_factorization_v<D>;
+constexpr Magnitude auto mag_ratio = detail::prime_factorization_v<N> / detail::prime_factorization_v<D>;
 
 /**
  * @brief  Create a Magnitude which is some rational number raised to a rational power.
  */
 MP_UNITS_EXPORT template<std::intmax_t Base, std::intmax_t Pow>
   requires detail::gt_zero<Base>
-inline constexpr Magnitude auto mag_power = pow<Pow>(mag<Base>);
+constexpr Magnitude auto mag_power = pow<Pow>(mag<Base>);
 
 namespace detail {
 
@@ -960,7 +959,7 @@ template<typename T, auto... Ms>
   return integer_part((detail::abs(power_of_2) < detail::abs(power_of_5)) ? power_of_2 : power_of_5);
 }
 
-inline constexpr symbol_text base_multiplier(u8"× 10", "x 10");
+constexpr symbol_text base_multiplier(u8"× 10", "x 10");
 
 template<Magnitude auto M>
 [[nodiscard]] consteval auto magnitude_text()
diff --git a/src/core/include/mp-units/framework/quantity_concepts.h b/src/core/include/mp-units/framework/quantity_concepts.h
index 37929f19..66b03efe 100644
--- a/src/core/include/mp-units/framework/quantity_concepts.h
+++ b/src/core/include/mp-units/framework/quantity_concepts.h
@@ -40,8 +40,7 @@ template<auto R, typename Rep>
 void to_base_specialization_of_quantity(const volatile quantity<R, Rep>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_quantity =
-  requires(T* t) { to_base_specialization_of_quantity(t); };
+constexpr bool is_derived_from_specialization_of_quantity = requires(T* t) { to_base_specialization_of_quantity(t); };
 
 }  // namespace detail
 
diff --git a/src/core/include/mp-units/framework/quantity_point.h b/src/core/include/mp-units/framework/quantity_point.h
index aa4763d6..a3d07fed 100644
--- a/src/core/include/mp-units/framework/quantity_point.h
+++ b/src/core/include/mp-units/framework/quantity_point.h
@@ -43,7 +43,7 @@ namespace mp_units {
 namespace detail {
 
 template<PointOrigin PO>
-inline constexpr bool is_specialization_of_zeroth_point_origin = false;
+constexpr bool is_specialization_of_zeroth_point_origin = false;
 
 template<PointOrigin PO>
 [[nodiscard]] consteval bool is_zeroth_point_origin(PO)
@@ -130,12 +130,12 @@ template<QuantitySpec auto QS>
 struct zeroth_point_origin_ final : absolute_point_origin<QS> {};
 
 MP_UNITS_EXPORT template<QuantitySpec auto QS>
-inline constexpr zeroth_point_origin_<QS> zeroth_point_origin;
+constexpr zeroth_point_origin_<QS> zeroth_point_origin;
 
 namespace detail {
 
 template<auto QS>
-inline constexpr bool is_specialization_of_zeroth_point_origin<zeroth_point_origin_<QS>> = true;
+constexpr bool is_specialization_of_zeroth_point_origin<zeroth_point_origin_<QS>> = true;
 
 }  // namespace detail
 
diff --git a/src/core/include/mp-units/framework/quantity_point_concepts.h b/src/core/include/mp-units/framework/quantity_point_concepts.h
index a262ea7d..8176f6a7 100644
--- a/src/core/include/mp-units/framework/quantity_point_concepts.h
+++ b/src/core/include/mp-units/framework/quantity_point_concepts.h
@@ -38,13 +38,13 @@ struct absolute_point_origin;
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_quantity_point = false;
+constexpr bool is_quantity_point = false;
 
 template<auto Q>
 void to_base_specialization_of_absolute_point_origin(const volatile absolute_point_origin<Q>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_absolute_point_origin =
+constexpr bool is_derived_from_specialization_of_absolute_point_origin =
   requires(T* t) { to_base_specialization_of_absolute_point_origin(t); };
 
 }  // namespace detail
@@ -66,7 +66,7 @@ template<auto QP>
 void to_base_specialization_of_relative_point_origin(const volatile relative_point_origin<QP>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_relative_point_origin =
+constexpr bool is_derived_from_specialization_of_relative_point_origin =
   requires(T* t) { to_base_specialization_of_relative_point_origin(t); };
 
 struct point_origin_interface;
@@ -99,12 +99,12 @@ template<auto R, auto PO, typename Rep>
 void to_base_specialization_of_quantity_point(const volatile quantity_point<R, PO, Rep>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_quantity_point =
+constexpr bool is_derived_from_specialization_of_quantity_point =
   requires(T* t) { to_base_specialization_of_quantity_point(t); };
 
 template<typename T>
   requires is_derived_from_specialization_of_quantity_point<T>
-inline constexpr bool is_quantity_point<T> = true;
+constexpr bool is_quantity_point<T> = true;
 
 template<PointOrigin PO1, PointOrigin PO2>
 [[nodiscard]] consteval bool same_absolute_point_origins(PO1 po1, PO2 po2)
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index 88eec204..a58a73e1 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -189,7 +189,7 @@ struct quantity_spec_interface : quantity_spec_interface_base {
 
 MP_UNITS_EXPORT_BEGIN
 
-inline constexpr struct is_kind {
+constexpr struct is_kind {
 } is_kind;
 
 /**
@@ -235,13 +235,13 @@ MP_UNITS_EXPORT_END
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
- * inline constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
- * inline constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
+ * constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+ * constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
+ * constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
  *
- * inline constexpr struct length final : quantity_spec<dim_length> {} length;
- * inline constexpr struct mass final : quantity_spec<dim_mass> {} mass;
- * inline constexpr struct time final : quantity_spec<dim_time> {} time;
+ * constexpr struct length final : quantity_spec<dim_length> {} length;
+ * constexpr struct mass final : quantity_spec<dim_mass> {} mass;
+ * constexpr struct time final : quantity_spec<dim_time> {} time;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -280,12 +280,12 @@ struct quantity_spec<Self, Dim, Args...> : detail::quantity_spec_interface<Self>
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct area final : quantity_spec<pow<2>(length)> {} area;
- * inline constexpr struct volume final : quantity_spec<pow<3>(length)> {} volume;
- * inline constexpr struct velocity final : quantity_spec<position_vector / duration> {} velocity;
- * inline constexpr struct speed final : quantity_spec<length / time> {} speed;
- * inline constexpr struct force final : quantity_spec<mass * acceleration, quantity_character::vector> {} force;
- * inline constexpr struct power final : quantity_spec<force * velocity, quantity_character::scalar> {} power;
+ * constexpr struct area final : quantity_spec<pow<2>(length)> {} area;
+ * constexpr struct volume final : quantity_spec<pow<3>(length)> {} volume;
+ * constexpr struct velocity final : quantity_spec<position_vector / duration> {} velocity;
+ * constexpr struct speed final : quantity_spec<length / time> {} speed;
+ * constexpr struct force final : quantity_spec<mass * acceleration, quantity_character::vector> {} force;
+ * constexpr struct power final : quantity_spec<force * velocity, quantity_character::scalar> {} power;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -335,10 +335,10 @@ struct propagate_equation<Q, true> {
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct width final : quantity_spec<length> {} width;
- * inline constexpr struct height final : quantity_spec<length> {} height;
- * inline constexpr struct diameter final : quantity_spec<width> {} diameter;
- * inline constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
+ * constexpr struct width final : quantity_spec<length> {} width;
+ * constexpr struct height final : quantity_spec<length> {} height;
+ * constexpr struct diameter final : quantity_spec<width> {} diameter;
+ * constexpr struct position_vector final : quantity_spec<length, quantity_character::vector> {} position_vector;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -396,10 +396,10 @@ struct quantity_spec<Self, QS, Args...> : detail::propagate_equation<QS>, detail
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct angular_measure final : quantity_spec<dimensionless, arc_length / radius, is_kind> {} angular_measure;
- * inline constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
- * inline constexpr struct weight final : quantity_spec<force, mass * acceleration_of_free_fall> {} weight;
- * inline constexpr struct kinetic_energy final : quantity_spec<mechanical_energy, mass * pow<2>(speed)> {} kinetic_energy;
+ * constexpr struct angular_measure final : quantity_spec<dimensionless, arc_length / radius, is_kind> {} angular_measure;
+ * constexpr struct velocity final : quantity_spec<speed, position_vector / duration> {} velocity;
+ * constexpr struct weight final : quantity_spec<force, mass * acceleration_of_free_fall> {} weight;
+ * constexpr struct kinetic_energy final : quantity_spec<mechanical_energy, mass * pow<2>(speed)> {} kinetic_energy;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -556,7 +556,7 @@ struct kind_of_<Q> final : quantity_spec<kind_of_<Q>, Q{}>::_base_type_ {
 
 MP_UNITS_EXPORT template<detail::QuantitySpecWithNoSpecifiers auto Q>
   requires detail::SameQuantitySpec<detail::get_kind_tree_root(Q), Q>
-inline constexpr kind_of_<MP_UNITS_REMOVE_CONST(decltype(Q))> kind_of;
+constexpr kind_of_<MP_UNITS_REMOVE_CONST(decltype(Q))> kind_of;
 
 namespace detail {
 
diff --git a/src/core/include/mp-units/framework/quantity_spec_concepts.h b/src/core/include/mp-units/framework/quantity_spec_concepts.h
index 9eac9f2d..296e7e9d 100644
--- a/src/core/include/mp-units/framework/quantity_spec_concepts.h
+++ b/src/core/include/mp-units/framework/quantity_spec_concepts.h
@@ -53,10 +53,10 @@ struct kind_of_;
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_specialization_of_kind_of = false;
+constexpr bool is_specialization_of_kind_of = false;
 
 template<typename Q>
-inline constexpr bool is_specialization_of_kind_of<kind_of_<Q>> = true;
+constexpr bool is_specialization_of_kind_of<kind_of_<Q>> = true;
 
 template<typename T>
 concept QuantityKindSpec = is_specialization_of_kind_of<T>;
@@ -70,7 +70,7 @@ void to_base_specialization_of_quantity_spec(const volatile quantity_spec<T, Arg
 #endif
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_quantity_spec =
+constexpr bool is_derived_from_specialization_of_quantity_spec =
   requires(T* t) { to_base_specialization_of_quantity_spec(t); };
 
 /**
@@ -86,16 +86,16 @@ template<typename T>
 struct is_dimensionless : std::false_type {};
 
 template<typename T>
-inline constexpr bool is_power_of_quantity_spec = requires {
+constexpr bool is_power_of_quantity_spec = requires {
   requires is_specialization_of_power<T> &&
              (NamedQuantitySpec<typename T::factor> || is_dimensionless<typename T::factor>::value);
 };
 
 template<typename T>
-inline constexpr bool is_per_of_quantity_specs = false;
+constexpr bool is_per_of_quantity_specs = false;
 
 template<typename... Ts>
-inline constexpr bool is_per_of_quantity_specs<per<Ts...>> =
+constexpr bool is_per_of_quantity_specs<per<Ts...>> =
   (... && (NamedQuantitySpec<Ts> || is_dimensionless<Ts>::value || is_power_of_quantity_spec<Ts>));
 
 template<typename T>
diff --git a/src/core/include/mp-units/framework/system_reference.h b/src/core/include/mp-units/framework/system_reference.h
index 3df21be2..6bac8d79 100644
--- a/src/core/include/mp-units/framework/system_reference.h
+++ b/src/core/include/mp-units/framework/system_reference.h
@@ -45,15 +45,15 @@ namespace mp_units {
  * @code{.cpp}
  * // hypothetical natural system of units for c=1
  *
- * inline constexpr struct second final : named_unit<"s"> {} second;
- * inline constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
- * inline constexpr struct gram final : named_unit<"g"> {} gram;
- * inline constexpr auto kilogram = si::kilo<gram>;
+ * constexpr struct second final : named_unit<"s"> {} second;
+ * constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
+ * constexpr struct gram final : named_unit<"g"> {} gram;
+ * constexpr auto kilogram = si::kilo<gram>;
  *
- * inline constexpr struct time : system_reference<isq::time, second> {} time;
- * inline constexpr struct length : system_reference<isq::length, second> {} length;
- * inline constexpr struct speed : system_reference<isq::speed, second / second> {} speed;
- * inline constexpr struct force : system_reference<isq::force, kilogram / second> {} force;
+ * constexpr struct time : system_reference<isq::time, second> {} time;
+ * constexpr struct length : system_reference<isq::length, second> {} length;
+ * constexpr struct speed : system_reference<isq::speed, second / second> {} speed;
+ * constexpr struct force : system_reference<isq::force, kilogram / second> {} force;
  * @endcode
  *
  * @tparam Q quantity for which a unit is being assigned
diff --git a/src/core/include/mp-units/framework/unit.h b/src/core/include/mp-units/framework/unit.h
index 411f3256..1e564107 100644
--- a/src/core/include/mp-units/framework/unit.h
+++ b/src/core/include/mp-units/framework/unit.h
@@ -64,7 +64,7 @@ template<Magnitude auto M, Unit U>
 struct scaled_unit_impl;
 
 template<typename T>
-inline constexpr bool is_specialization_of_scaled_unit = false;
+constexpr bool is_specialization_of_scaled_unit = false;
 
 template<DerivedUnitExpr... Expr>
 struct derived_unit_impl;
@@ -241,7 +241,7 @@ struct scaled_unit final : detail::scaled_unit_impl<M, U> {};
 namespace detail {
 
 template<auto M, Unit U>
-inline constexpr bool is_specialization_of_scaled_unit<scaled_unit<M, U>> = true;
+constexpr bool is_specialization_of_scaled_unit<scaled_unit<M, U>> = true;
 
 }  // namespace detail
 
@@ -256,12 +256,12 @@ inline constexpr bool is_specialization_of_scaled_unit<scaled_unit<M, U>> = true
  * For example:
  *
  * @code{.cpp}
- * inline constexpr struct second final : named_unit<"s", kind_of<time>> {} second;
- * inline constexpr struct metre final : named_unit<"m", kind_of<length> {} metre;
- * inline constexpr struct hertz final : named_unit<"Hz", inverse(second), kind_of<frequency>> {} hertz;
- * inline constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
- * inline constexpr struct degree_Celsius final : named_unit<{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {}
- * degree_Celsius; inline constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
+ * constexpr struct second final : named_unit<"s", kind_of<time>> {} second;
+ * constexpr struct metre final : named_unit<"m", kind_of<length> {} metre;
+ * constexpr struct hertz final : named_unit<"Hz", inverse(second), kind_of<frequency>> {} hertz;
+ * constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+ * constexpr struct degree_Celsius final : named_unit<{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {}
+ * degree_Celsius; constexpr struct minute final : named_unit<"min", mag<60> * second> {} minute;
  * @endcode
  *
  * @note A common convention in this library is to assign the same name for a type and an object of this type.
@@ -386,9 +386,9 @@ struct named_unit<Symbol, U, QS, PO> : decltype(U)::_base_type_ {
  * struct kilo_ : prefixed_unit<"k", mag_power<10, 3>, U> {};
  *
  * template<PrefixableUnit auto U>
- * inline constexpr kilo_<U> kilo;
+ * constexpr kilo_<U> kilo;
  *
- * inline constexpr auto kilogram = si::kilo<gram>;
+ * constexpr auto kilogram = si::kilo<gram>;
  * @endcode
  *
  * @tparam Symbol a prefix text to prepend to a unit symbol
@@ -468,7 +468,7 @@ struct derived_unit final : detail::derived_unit_impl<Expr...> {};
  * Unit of a dimensionless quantity.
  */
 // clang-format off
-MP_UNITS_EXPORT inline constexpr struct one final : detail::derived_unit_impl<> {} one;
+MP_UNITS_EXPORT constexpr struct one final : detail::derived_unit_impl<> {} one;
 // clang-format on
 
 namespace detail {
@@ -534,10 +534,10 @@ template<Unit T, typename... Expr>
 }
 
 template<typename T>
-inline constexpr bool is_specialization_of_derived_unit = false;
+constexpr bool is_specialization_of_derived_unit = false;
 
 template<typename... Expr>
-inline constexpr bool is_specialization_of_derived_unit<derived_unit<Expr...>> = true;
+constexpr bool is_specialization_of_derived_unit<derived_unit<Expr...>> = true;
 
 }  // namespace detail
 
@@ -611,10 +611,10 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Unit U>
 
 // common dimensionless units
 // clang-format off
-inline constexpr struct percent final : named_unit<"%", mag_ratio<1, 100> * one> {} percent;
-inline constexpr struct per_mille final : named_unit<symbol_text{u8"‰", "%o"}, mag_ratio<1, 1000> * one> {} per_mille;
-inline constexpr struct parts_per_million final : named_unit<"ppm", mag_ratio<1, 1'000'000> * one> {} parts_per_million;
-inline constexpr auto ppm = parts_per_million;
+constexpr struct percent final : named_unit<"%", mag_ratio<1, 100> * one> {} percent;
+constexpr struct per_mille final : named_unit<symbol_text{u8"‰", "%o"}, mag_ratio<1, 1000> * one> {} per_mille;
+constexpr struct parts_per_million final : named_unit<"ppm", mag_ratio<1, 1'000'000> * one> {} parts_per_million;
+constexpr auto ppm = parts_per_million;
 // clang-format on
 
 
@@ -675,14 +675,14 @@ template<Unit U1, Unit U2>
  * be provided.
  */
 template<Unit auto U>
-inline constexpr bool space_before_unit_symbol = true;
+constexpr bool space_before_unit_symbol = true;
 
 template<>
-inline constexpr bool space_before_unit_symbol<one> = false;
+constexpr bool space_before_unit_symbol<one> = false;
 template<>
-inline constexpr bool space_before_unit_symbol<percent> = false;
+constexpr bool space_before_unit_symbol<percent> = false;
 template<>
-inline constexpr bool space_before_unit_symbol<per_mille> = false;
+constexpr bool space_before_unit_symbol<per_mille> = false;
 
 // get_unit_symbol
 
diff --git a/src/core/include/mp-units/framework/unit_concepts.h b/src/core/include/mp-units/framework/unit_concepts.h
index 56e15c65..e9244542 100644
--- a/src/core/include/mp-units/framework/unit_concepts.h
+++ b/src/core/include/mp-units/framework/unit_concepts.h
@@ -59,7 +59,7 @@ template<symbol_text Symbol, auto... Args>
 void to_base_specialization_of_named_unit(const volatile named_unit<Symbol, Args...>*);
 
 template<typename T>
-inline constexpr bool is_derived_from_specialization_of_named_unit =
+constexpr bool is_derived_from_specialization_of_named_unit =
   requires(T* t) { to_base_specialization_of_named_unit(t); };
 
 }  // namespace detail
@@ -73,14 +73,13 @@ concept PrefixableUnit = Unit<T> && detail::is_derived_from_specialization_of_na
 namespace detail {
 
 template<typename T>
-inline constexpr bool is_power_of_unit =
-  requires { requires is_specialization_of_power<T> && Unit<typename T::factor>; };
+constexpr bool is_power_of_unit = requires { requires is_specialization_of_power<T> && Unit<typename T::factor>; };
 
 template<typename T>
-inline constexpr bool is_per_of_units = false;
+constexpr bool is_per_of_units = false;
 
 template<typename... Ts>
-inline constexpr bool is_per_of_units<per<Ts...>> = (... && (Unit<Ts> || is_power_of_unit<Ts>));
+constexpr bool is_per_of_units<per<Ts...>> = (... && (Unit<Ts> || is_power_of_unit<Ts>));
 
 template<typename T>
 concept DerivedUnitExpr = Unit<T> || detail::is_power_of_unit<T> || detail::is_per_of_units<T>;
diff --git a/src/core/include/mp-units/framework/value_cast.h b/src/core/include/mp-units/framework/value_cast.h
index 6da41b2d..7aeb11d0 100644
--- a/src/core/include/mp-units/framework/value_cast.h
+++ b/src/core/include/mp-units/framework/value_cast.h
@@ -184,7 +184,7 @@ template<Unit auto ToU, Representation ToRep, typename QP>
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (e.g. non-truncating) conversion. In truncating cases an explicit cast have to be used.
  *
- * inline constexpr struct A : absolute_point_origin<A, isq::distance> A;
+ * constexpr struct A : absolute_point_origin<A, isq::distance> A;
  *
  * using ToQ = quantity<mm, int>;
  * auto qp = value_cast<ToQ>(quantity_point{1.23 * m});
@@ -210,8 +210,8 @@ template<Quantity ToQ, typename QP>
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (e.g. non-truncating) conversion. In truncating cases an explicit cast have to be used.
  *
- * inline constexpr struct A : absolute_point_origin<A, isq::distance> A;
- * inline constexpr struct B : relative_point_origin<A + 1*m> B;
+ * constexpr struct A : absolute_point_origin<A, isq::distance> A;
+ * constexpr struct B : relative_point_origin<A + 1*m> B;
  *
  * using ToQP = quantity_point<mm, B, int>;
  * auto qp = value_cast<ToQP>(quantity_point{1.23 * m});
diff --git a/src/systems/include/mp-units/systems/angular/units.h b/src/systems/include/mp-units/systems/angular/units.h
index b8ebdfd9..75e5eaea 100644
--- a/src/systems/include/mp-units/systems/angular/units.h
+++ b/src/systems/include/mp-units/systems/angular/units.h
@@ -36,34 +36,34 @@ namespace mp_units {
 namespace angular {
 
 // clang-format off
-inline constexpr struct dim_angle final : base_dimension<"A"> {} dim_angle;
+constexpr struct dim_angle final : base_dimension<"A"> {} dim_angle;
 QUANTITY_SPEC(angle, dim_angle);
 QUANTITY_SPEC(solid_angle, pow<2>(angle));
 
-inline constexpr struct radian final : named_unit<"rad", kind_of<angle>> {} radian;
-inline constexpr struct revolution final : named_unit<"rev", mag<2> * mag_pi * radian> {} revolution;
-inline constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_ratio<1, 360> * revolution> {} degree;
-inline constexpr struct gradian final : named_unit<symbol_text{u8"ᵍ", "grad"}, mag_ratio<1, 400> * revolution> {} gradian;
-inline constexpr struct steradian final : named_unit<"sr", square(radian)> {} steradian;
+constexpr struct radian final : named_unit<"rad", kind_of<angle>> {} radian;
+constexpr struct revolution final : named_unit<"rev", mag<2> * mag_pi * radian> {} revolution;
+constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_ratio<1, 360> * revolution> {} degree;
+constexpr struct gradian final : named_unit<symbol_text{u8"ᵍ", "grad"}, mag_ratio<1, 400> * revolution> {} gradian;
+constexpr struct steradian final : named_unit<"sr", square(radian)> {} steradian;
 // clang-format on
 
 namespace unit_symbols {
 
-inline constexpr auto rad = radian;
-inline constexpr auto rev = revolution;
-inline constexpr auto deg = degree;
-inline constexpr auto grad = gradian;
-inline constexpr auto sr = steradian;
-inline constexpr auto rad2 = square(radian);
-inline constexpr auto deg2 = square(degree);
+constexpr auto rad = radian;
+constexpr auto rev = revolution;
+constexpr auto deg = degree;
+constexpr auto grad = gradian;
+constexpr auto sr = steradian;
+constexpr auto rad2 = square(radian);
+constexpr auto deg2 = square(degree);
 
 }  // namespace unit_symbols
 
 }  // namespace angular
 
 template<>
-inline constexpr bool space_before_unit_symbol<angular::degree> = false;
+constexpr bool space_before_unit_symbol<angular::degree> = false;
 template<>
-inline constexpr bool space_before_unit_symbol<angular::gradian> = false;
+constexpr bool space_before_unit_symbol<angular::gradian> = false;
 
 }  // namespace mp_units
diff --git a/src/systems/include/mp-units/systems/cgs.h b/src/systems/include/mp-units/systems/cgs.h
index 9ae0d265..ad65a7fa 100644
--- a/src/systems/include/mp-units/systems/cgs.h
+++ b/src/systems/include/mp-units/systems/cgs.h
@@ -35,35 +35,35 @@ MP_UNITS_EXPORT
 namespace mp_units::cgs {
 
 // clang-format off
-inline constexpr auto centimetre = si::centi<si::metre>;
-inline constexpr auto gram = si::gram;
-inline constexpr auto second = si::second;
-inline constexpr struct gal final : named_unit<"Gal", centimetre / square(second)> {} gal;
-inline constexpr struct dyne final : named_unit<"dyn", gram * centimetre / square(second)> {} dyne;
-inline constexpr struct erg final : named_unit<"erg", dyne * centimetre> {} erg;
-inline constexpr struct barye final : named_unit<"Ba", gram / (centimetre * square(second))> {} barye;
-inline constexpr struct poise final : named_unit<"P", gram / (centimetre * second)> {} poise;
-inline constexpr struct stokes final : named_unit<"St", square(centimetre) / second> {} stokes;
-inline constexpr struct kayser final : named_unit<"K", one / centimetre> {} kayser;
+constexpr auto centimetre = si::centi<si::metre>;
+constexpr auto gram = si::gram;
+constexpr auto second = si::second;
+constexpr struct gal final : named_unit<"Gal", centimetre / square(second)> {} gal;
+constexpr struct dyne final : named_unit<"dyn", gram * centimetre / square(second)> {} dyne;
+constexpr struct erg final : named_unit<"erg", dyne * centimetre> {} erg;
+constexpr struct barye final : named_unit<"Ba", gram / (centimetre * square(second))> {} barye;
+constexpr struct poise final : named_unit<"P", gram / (centimetre * second)> {} poise;
+constexpr struct stokes final : named_unit<"St", square(centimetre) / second> {} stokes;
+constexpr struct kayser final : named_unit<"K", one / centimetre> {} kayser;
 // clang-format on
 
 namespace unit_symbols {
 
-inline constexpr auto cm = centimetre;
-inline constexpr auto g = gram;
-inline constexpr auto s = second;
-inline constexpr auto Gal = gal;
-inline constexpr auto dyn = dyne;
-inline constexpr auto Ba = barye;
-inline constexpr auto P = poise;
-inline constexpr auto St = stokes;
-inline constexpr auto K = kayser;
+constexpr auto cm = centimetre;
+constexpr auto g = gram;
+constexpr auto s = second;
+constexpr auto Gal = gal;
+constexpr auto dyn = dyne;
+constexpr auto Ba = barye;
+constexpr auto P = poise;
+constexpr auto St = stokes;
+constexpr auto K = kayser;
 
 // commonly used squared and cubic units
-inline constexpr auto cm2 = square(centimetre);
-inline constexpr auto cm3 = cubic(centimetre);
-inline constexpr auto s2 = square(second);
-inline constexpr auto s3 = cubic(second);
+constexpr auto cm2 = square(centimetre);
+constexpr auto cm3 = cubic(centimetre);
+constexpr auto s2 = square(second);
+constexpr auto s3 = cubic(second);
 
 }  // namespace unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/hep.h b/src/systems/include/mp-units/systems/hep.h
index 77f6a516..8ea81cc3 100644
--- a/src/systems/include/mp-units/systems/hep.h
+++ b/src/systems/include/mp-units/systems/hep.h
@@ -36,7 +36,7 @@ MP_UNITS_EXPORT
 namespace mp_units {
 
 template<>
-inline constexpr std::optional<std::intmax_t> known_first_factor<334'524'384'739> = 334'524'384'739;
+constexpr std::optional<std::intmax_t> known_first_factor<334'524'384'739> = 334'524'384'739;
 
 namespace hep {
 
@@ -49,64 +49,64 @@ using si::electronvolt;
 // effective cross-sectional area according to EU council directive 80/181/EEC
 // https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:01980L0181-20090527#page=10
 // https://www.fedlex.admin.ch/eli/cc/1994/3109_3109_3109/de
-inline constexpr struct barn final : named_unit<"b", mag_power<10, -28> * square(si::metre)> {} barn;
+constexpr struct barn final : named_unit<"b", mag_power<10, -28> * square(si::metre)> {} barn;
 
 // mass
-inline constexpr struct electron_mass final : named_unit<"m_e", mag_ratio<9'109'383'701'528, 1'000'000'000'000> * mag_power<10, -31> * si::kilogram> {} electron_mass;
-inline constexpr struct proton_mass final : named_unit<"m_p", mag_ratio<1'672'621'923'695, 1'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} proton_mass;
-inline constexpr struct neutron_mass final : named_unit<"m_n", mag_ratio<1'674'927'498'049, 1'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} neutron_mass;
+constexpr struct electron_mass final : named_unit<"m_e", mag_ratio<9'109'383'701'528, 1'000'000'000'000> * mag_power<10, -31> * si::kilogram> {} electron_mass;
+constexpr struct proton_mass final : named_unit<"m_p", mag_ratio<1'672'621'923'695, 1'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} proton_mass;
+constexpr struct neutron_mass final : named_unit<"m_n", mag_ratio<1'674'927'498'049, 1'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} neutron_mass;
 
 // speed
-inline constexpr auto speed_of_light = si::si2019::speed_of_light_in_vacuum;
+constexpr auto speed_of_light = si::si2019::speed_of_light_in_vacuum;
 // clang-format on
 
 namespace unit_symbols {
 
 using si::unit_symbols::eV;
 
-inline constexpr auto qeV = si::quecto<electronvolt>;
-inline constexpr auto reV = si::ronto<electronvolt>;
-inline constexpr auto yeV = si::yocto<electronvolt>;
-inline constexpr auto zeV = si::zepto<electronvolt>;
-inline constexpr auto aeV = si::atto<electronvolt>;
-inline constexpr auto feV = si::femto<electronvolt>;
-inline constexpr auto peV = si::pico<electronvolt>;
-inline constexpr auto neV = si::nano<electronvolt>;
-inline constexpr auto ueV = si::micro<electronvolt>;
-inline constexpr auto meV = si::milli<electronvolt>;
-inline constexpr auto ceV = si::centi<electronvolt>;
-inline constexpr auto deV = si::deci<electronvolt>;
-inline constexpr auto daeV = si::deca<electronvolt>;
-inline constexpr auto heV = si::hecto<electronvolt>;
-inline constexpr auto keV = si::kilo<electronvolt>;
-inline constexpr auto MeV = si::mega<electronvolt>;
-inline constexpr auto GeV = si::giga<electronvolt>;
-inline constexpr auto TeV = si::tera<electronvolt>;
-inline constexpr auto PeV = si::peta<electronvolt>;
-inline constexpr auto EeV = si::exa<electronvolt>;
-inline constexpr auto ZeV = si::zetta<electronvolt>;
-inline constexpr auto YeV = si::yotta<electronvolt>;
-inline constexpr auto ReV = si::ronna<electronvolt>;
-inline constexpr auto QeV = si::quetta<electronvolt>;
+constexpr auto qeV = si::quecto<electronvolt>;
+constexpr auto reV = si::ronto<electronvolt>;
+constexpr auto yeV = si::yocto<electronvolt>;
+constexpr auto zeV = si::zepto<electronvolt>;
+constexpr auto aeV = si::atto<electronvolt>;
+constexpr auto feV = si::femto<electronvolt>;
+constexpr auto peV = si::pico<electronvolt>;
+constexpr auto neV = si::nano<electronvolt>;
+constexpr auto ueV = si::micro<electronvolt>;
+constexpr auto meV = si::milli<electronvolt>;
+constexpr auto ceV = si::centi<electronvolt>;
+constexpr auto deV = si::deci<electronvolt>;
+constexpr auto daeV = si::deca<electronvolt>;
+constexpr auto heV = si::hecto<electronvolt>;
+constexpr auto keV = si::kilo<electronvolt>;
+constexpr auto MeV = si::mega<electronvolt>;
+constexpr auto GeV = si::giga<electronvolt>;
+constexpr auto TeV = si::tera<electronvolt>;
+constexpr auto PeV = si::peta<electronvolt>;
+constexpr auto EeV = si::exa<electronvolt>;
+constexpr auto ZeV = si::zetta<electronvolt>;
+constexpr auto YeV = si::yotta<electronvolt>;
+constexpr auto ReV = si::ronna<electronvolt>;
+constexpr auto QeV = si::quetta<electronvolt>;
 
-inline constexpr auto qb = si::quecto<barn>;
-inline constexpr auto rb = si::ronto<barn>;
-inline constexpr auto yb = si::yocto<barn>;
-inline constexpr auto zb = si::zepto<barn>;
-inline constexpr auto ab = si::atto<barn>;
-inline constexpr auto fb = si::femto<barn>;
-inline constexpr auto pb = si::pico<barn>;
-inline constexpr auto nb = si::nano<barn>;
-inline constexpr auto ub = si::micro<barn>;
-inline constexpr auto mb = si::milli<barn>;
-inline constexpr auto b = barn;
+constexpr auto qb = si::quecto<barn>;
+constexpr auto rb = si::ronto<barn>;
+constexpr auto yb = si::yocto<barn>;
+constexpr auto zb = si::zepto<barn>;
+constexpr auto ab = si::atto<barn>;
+constexpr auto fb = si::femto<barn>;
+constexpr auto pb = si::pico<barn>;
+constexpr auto nb = si::nano<barn>;
+constexpr auto ub = si::micro<barn>;
+constexpr auto mb = si::milli<barn>;
+constexpr auto b = barn;
 
-inline constexpr auto m_e = electron_mass;
-inline constexpr auto m_p = proton_mass;
-inline constexpr auto m_n = neutron_mass;
+constexpr auto m_e = electron_mass;
+constexpr auto m_p = proton_mass;
+constexpr auto m_n = neutron_mass;
 
-inline constexpr auto c = speed_of_light;
-inline constexpr auto c2 = square(speed_of_light);
+constexpr auto c = speed_of_light;
+constexpr auto c2 = square(speed_of_light);
 
 }  // namespace unit_symbols
 }  // namespace hep
diff --git a/src/systems/include/mp-units/systems/iau.h b/src/systems/include/mp-units/systems/iau.h
index c81777aa..d08c0c73 100644
--- a/src/systems/include/mp-units/systems/iau.h
+++ b/src/systems/include/mp-units/systems/iau.h
@@ -39,65 +39,65 @@ namespace mp_units::iau {
 
 // clang-format off
 // time
-inline constexpr struct day final : named_unit<"D", si::day> {} day;
-inline constexpr struct Julian_year final : named_unit<"a", mag_ratio<365'25, 100> * day> {} Julian_year;
+constexpr struct day final : named_unit<"D", si::day> {} day;
+constexpr struct Julian_year final : named_unit<"a", mag_ratio<365'25, 100> * day> {} Julian_year;
 
 // mass
 // https://en.wikipedia.org/wiki/Solar_mass
 // TODO What is the official mass of sun (every source in the Internet provides a different value)
-inline constexpr struct solar_mass final : named_unit<symbol_text{u8"M_☉", "M_SUN"}, mag_ratio<198'847, 100'000> * mag_power<10, 30> * si::kilogram> {} solar_mass;
-inline constexpr struct Jupiter_mass final : named_unit<"M_JUP", mag_ratio<1'898, 1'000> * mag_power<10, 27> * si::kilogram> {} Jupiter_mass;
-inline constexpr struct Earth_mass final : named_unit<"M_EARTH", mag_ratio<59'742, 10'000> * mag_power<10, 24> * si::kilogram> {} Earth_mass;
+constexpr struct solar_mass final : named_unit<symbol_text{u8"M_☉", "M_SUN"}, mag_ratio<198'847, 100'000> * mag_power<10, 30> * si::kilogram> {} solar_mass;
+constexpr struct Jupiter_mass final : named_unit<"M_JUP", mag_ratio<1'898, 1'000> * mag_power<10, 27> * si::kilogram> {} Jupiter_mass;
+constexpr struct Earth_mass final : named_unit<"M_EARTH", mag_ratio<59'742, 10'000> * mag_power<10, 24> * si::kilogram> {} Earth_mass;
 
 // length
-inline constexpr auto astronomical_unit = si::astronomical_unit;
+constexpr auto astronomical_unit = si::astronomical_unit;
 
 // https://en.wikipedia.org/wiki/Lunar_distance_(astronomy)
-inline constexpr struct lunar_distance final : named_unit<"LD", mag<384'399> * si::kilo<si::metre>> {} lunar_distance;
+constexpr struct lunar_distance final : named_unit<"LD", mag<384'399> * si::kilo<si::metre>> {} lunar_distance;
 
 // https://en.wikipedia.org/wiki/Light-year
-inline constexpr struct light_year final : named_unit<"ly", mag<9'460'730'472'580'800> * si::metre> {} light_year;
+constexpr struct light_year final : named_unit<"ly", mag<9'460'730'472'580'800> * si::metre> {} light_year;
 
 // https://en.wikipedia.org/wiki/Parsec
-inline constexpr struct parsec final : named_unit<"pc", astronomical_unit / (mag_ratio<1, 3600> * si::degree)> {} parsec;
+constexpr struct parsec final : named_unit<"pc", astronomical_unit / (mag_ratio<1, 3600> * si::degree)> {} parsec;
 
 // https://en.wikipedia.org/wiki/Angstrom
-inline constexpr struct angstrom final : named_unit<symbol_text{u8"Å", "A"}, mag_power<10, -10> * si::metre> {} angstrom;
+constexpr struct angstrom final : named_unit<symbol_text{u8"Å", "A"}, mag_power<10, -10> * si::metre> {} angstrom;
 
 // selected constants
 // https://en.wikipedia.org/wiki/Astronomical_constant
-inline constexpr struct gaussian_gravitational_constant final :
+constexpr struct gaussian_gravitational_constant final :
     named_unit<"k", mag_ratio<1'720'209'895, 100'000'000'000> * pow<3, 2>(astronomical_unit) / pow<1,2>(solar_mass) / day> {} gaussian_gravitational_constant;
 
-inline constexpr struct speed_of_light final :
+constexpr struct speed_of_light final :
     named_unit<symbol_text{u8"c₀", "c_0"}, si::si2019::speed_of_light_in_vacuum> {} speed_of_light;
 
-inline constexpr struct constant_of_gravitation final :
+constexpr struct constant_of_gravitation final :
     named_unit<"G", mag_ratio<667'430, 100'000> * mag_power<10, -11> * cubic(si::metre) / si::kilogram / square(si::second)> {} constant_of_gravitation;
 
-inline constexpr struct hubble_constant final :
+constexpr struct hubble_constant final :
     named_unit<symbol_text{u8"H₀", "H_0"}, mag_ratio<701, 10> * si::kilo<si::metre> / si::second / si::mega<parsec>> {} hubble_constant;
 // clang-format on
 
 namespace unit_symbols {
 
-inline constexpr auto D = day;
-inline constexpr auto a = Julian_year;
+constexpr auto D = day;
+constexpr auto a = Julian_year;
 
-inline constexpr auto M_SUN = solar_mass;
-inline constexpr auto M_JUP = Jupiter_mass;
-inline constexpr auto M_EARTH = Earth_mass;
+constexpr auto M_SUN = solar_mass;
+constexpr auto M_JUP = Jupiter_mass;
+constexpr auto M_EARTH = Earth_mass;
 
-inline constexpr auto au = astronomical_unit;
-inline constexpr auto LD = lunar_distance;
-inline constexpr auto ly = light_year;
-inline constexpr auto pc = parsec;
-inline constexpr auto A = angstrom;
+constexpr auto au = astronomical_unit;
+constexpr auto LD = lunar_distance;
+constexpr auto ly = light_year;
+constexpr auto pc = parsec;
+constexpr auto A = angstrom;
 
-inline constexpr auto k = gaussian_gravitational_constant;
-inline constexpr auto c_0 = speed_of_light;
-inline constexpr auto G = constant_of_gravitation;
-inline constexpr auto H_0 = hubble_constant;
+constexpr auto k = gaussian_gravitational_constant;
+constexpr auto c_0 = speed_of_light;
+constexpr auto G = constant_of_gravitation;
+constexpr auto H_0 = hubble_constant;
 
 }  // namespace unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/iec80000/binary_prefixes.h b/src/systems/include/mp-units/systems/iec80000/binary_prefixes.h
index 5eb39132..e09a218d 100644
--- a/src/systems/include/mp-units/systems/iec80000/binary_prefixes.h
+++ b/src/systems/include/mp-units/systems/iec80000/binary_prefixes.h
@@ -42,14 +42,14 @@ template<PrefixableUnit U> struct yobi_ final : prefixed_unit<"Yi", mag_power<2,
 
 MP_UNITS_EXPORT_BEGIN
 
-template<PrefixableUnit auto U> inline constexpr kibi_<MP_UNITS_REMOVE_CONST(decltype(U))> kibi;
-template<PrefixableUnit auto U> inline constexpr mebi_<MP_UNITS_REMOVE_CONST(decltype(U))> mebi;
-template<PrefixableUnit auto U> inline constexpr gibi_<MP_UNITS_REMOVE_CONST(decltype(U))> gibi;
-template<PrefixableUnit auto U> inline constexpr tebi_<MP_UNITS_REMOVE_CONST(decltype(U))> tebi;
-template<PrefixableUnit auto U> inline constexpr pebi_<MP_UNITS_REMOVE_CONST(decltype(U))> pebi;
-template<PrefixableUnit auto U> inline constexpr exbi_<MP_UNITS_REMOVE_CONST(decltype(U))> exbi;
-template<PrefixableUnit auto U> inline constexpr zebi_<MP_UNITS_REMOVE_CONST(decltype(U))> zebi;
-template<PrefixableUnit auto U> inline constexpr yobi_<MP_UNITS_REMOVE_CONST(decltype(U))> yobi;
+template<PrefixableUnit auto U> constexpr kibi_<MP_UNITS_REMOVE_CONST(decltype(U))> kibi;
+template<PrefixableUnit auto U> constexpr mebi_<MP_UNITS_REMOVE_CONST(decltype(U))> mebi;
+template<PrefixableUnit auto U> constexpr gibi_<MP_UNITS_REMOVE_CONST(decltype(U))> gibi;
+template<PrefixableUnit auto U> constexpr tebi_<MP_UNITS_REMOVE_CONST(decltype(U))> tebi;
+template<PrefixableUnit auto U> constexpr pebi_<MP_UNITS_REMOVE_CONST(decltype(U))> pebi;
+template<PrefixableUnit auto U> constexpr exbi_<MP_UNITS_REMOVE_CONST(decltype(U))> exbi;
+template<PrefixableUnit auto U> constexpr zebi_<MP_UNITS_REMOVE_CONST(decltype(U))> zebi;
+template<PrefixableUnit auto U> constexpr yobi_<MP_UNITS_REMOVE_CONST(decltype(U))> yobi;
 // clang-format on
 
 MP_UNITS_EXPORT_END
diff --git a/src/systems/include/mp-units/systems/iec80000/quantities.h b/src/systems/include/mp-units/systems/iec80000/quantities.h
index f9b23547..f4717308 100644
--- a/src/systems/include/mp-units/systems/iec80000/quantities.h
+++ b/src/systems/include/mp-units/systems/iec80000/quantities.h
@@ -36,40 +36,40 @@ namespace mp_units::iec80000 {
 
 // dimensions of base quantities
 // clang-format off
-inline constexpr struct dim_traffic_intensity final : base_dimension<"A"> {} dim_traffic_intensity;
+constexpr struct dim_traffic_intensity final : base_dimension<"A"> {} dim_traffic_intensity;
 // clang-format on
 
 // quantities
 QUANTITY_SPEC(traffic_intensity, dim_traffic_intensity);
 QUANTITY_SPEC(traffic_offered_intensity, traffic_intensity);
 QUANTITY_SPEC(traffic_carried_intensity, traffic_intensity);
-inline constexpr auto traffic_load = traffic_carried_intensity;
+constexpr auto traffic_load = traffic_carried_intensity;
 QUANTITY_SPEC(mean_queue_length, dimensionless);
 QUANTITY_SPEC(loss_probability, dimensionless);
 QUANTITY_SPEC(waiting_probability, dimensionless);
 QUANTITY_SPEC(call_intensity, inverse(isq::duration));
-inline constexpr auto calling_rate = call_intensity;
+constexpr auto calling_rate = call_intensity;
 QUANTITY_SPEC(completed_call_intensity, call_intensity);
 QUANTITY_SPEC(storage_capacity, dimensionless, is_kind);
-inline constexpr auto storage_size = storage_capacity;
+constexpr auto storage_size = storage_capacity;
 QUANTITY_SPEC(equivalent_binary_storage_capacity, storage_capacity);
 QUANTITY_SPEC(transfer_rate, storage_capacity / isq::duration);
 QUANTITY_SPEC(period_of_data_elements, isq::period, inverse(transfer_rate));
 QUANTITY_SPEC(binary_digit_rate, transfer_rate);
-inline constexpr auto bit_rate = binary_digit_rate;
+constexpr auto bit_rate = binary_digit_rate;
 QUANTITY_SPEC(period_of_binary_digits, isq::period, inverse(binary_digit_rate));
-inline constexpr auto bit_period = period_of_binary_digits;
+constexpr auto bit_period = period_of_binary_digits;
 QUANTITY_SPEC(equivalent_binary_digit_rate, binary_digit_rate);
-inline constexpr auto equivalent_bit_rate = bit_rate;
+constexpr auto equivalent_bit_rate = bit_rate;
 QUANTITY_SPEC(modulation_rate, inverse(isq::duration));
-inline constexpr auto line_digit_rate = modulation_rate;
+constexpr auto line_digit_rate = modulation_rate;
 QUANTITY_SPEC(quantizing_distortion_power, isq::power);
 QUANTITY_SPEC(carrier_power, isq::power);
 QUANTITY_SPEC(signal_energy_per_binary_digit, carrier_power* period_of_binary_digits);
 QUANTITY_SPEC(error_probability, dimensionless);
 QUANTITY_SPEC(Hamming_distance, dimensionless);
 QUANTITY_SPEC(clock_frequency, isq::frequency);
-inline constexpr auto clock_rate = clock_frequency;
+constexpr auto clock_rate = clock_frequency;
 QUANTITY_SPEC(decision_content, dimensionless);
 
 // TODO how to model information_content and the following quantities???
diff --git a/src/systems/include/mp-units/systems/iec80000/unit_symbols.h b/src/systems/include/mp-units/systems/iec80000/unit_symbols.h
index 53d423a8..873d731f 100644
--- a/src/systems/include/mp-units/systems/iec80000/unit_symbols.h
+++ b/src/systems/include/mp-units/systems/iec80000/unit_symbols.h
@@ -31,81 +31,81 @@ MP_UNITS_EXPORT
 namespace mp_units::iec80000::unit_symbols {
 
 // bit
-inline constexpr auto kbit = si::kilo<bit>;
-inline constexpr auto Mbit = si::mega<bit>;
-inline constexpr auto Gbit = si::giga<bit>;
-inline constexpr auto Tbit = si::tera<bit>;
-inline constexpr auto Pbit = si::peta<bit>;
-inline constexpr auto Ebit = si::exa<bit>;
-inline constexpr auto Zbit = si::zetta<bit>;
-inline constexpr auto Ybit = si::yotta<bit>;
-inline constexpr auto Rbit = si::ronna<bit>;
-inline constexpr auto Qbit = si::quetta<bit>;
+constexpr auto kbit = si::kilo<bit>;
+constexpr auto Mbit = si::mega<bit>;
+constexpr auto Gbit = si::giga<bit>;
+constexpr auto Tbit = si::tera<bit>;
+constexpr auto Pbit = si::peta<bit>;
+constexpr auto Ebit = si::exa<bit>;
+constexpr auto Zbit = si::zetta<bit>;
+constexpr auto Ybit = si::yotta<bit>;
+constexpr auto Rbit = si::ronna<bit>;
+constexpr auto Qbit = si::quetta<bit>;
 
-inline constexpr auto Kibit = kibi<bit>;
-inline constexpr auto Mibit = mebi<bit>;
-inline constexpr auto Gibit = gibi<bit>;
-inline constexpr auto Tibit = tebi<bit>;
-inline constexpr auto Pibit = pebi<bit>;
-inline constexpr auto Eibit = exbi<bit>;
+constexpr auto Kibit = kibi<bit>;
+constexpr auto Mibit = mebi<bit>;
+constexpr auto Gibit = gibi<bit>;
+constexpr auto Tibit = tebi<bit>;
+constexpr auto Pibit = pebi<bit>;
+constexpr auto Eibit = exbi<bit>;
 
 // octet
-inline constexpr auto o = octet;
+constexpr auto o = octet;
 
-inline constexpr auto ko = si::kilo<octet>;
-inline constexpr auto Mo = si::mega<octet>;
-inline constexpr auto Go = si::giga<octet>;
-inline constexpr auto To = si::tera<octet>;
-inline constexpr auto Po = si::peta<octet>;
-inline constexpr auto Eo = si::exa<octet>;
-inline constexpr auto Zo = si::zetta<octet>;
-inline constexpr auto Yo = si::yotta<octet>;
-inline constexpr auto Ro = si::ronna<octet>;
-inline constexpr auto Qo = si::quetta<octet>;
+constexpr auto ko = si::kilo<octet>;
+constexpr auto Mo = si::mega<octet>;
+constexpr auto Go = si::giga<octet>;
+constexpr auto To = si::tera<octet>;
+constexpr auto Po = si::peta<octet>;
+constexpr auto Eo = si::exa<octet>;
+constexpr auto Zo = si::zetta<octet>;
+constexpr auto Yo = si::yotta<octet>;
+constexpr auto Ro = si::ronna<octet>;
+constexpr auto Qo = si::quetta<octet>;
 
-inline constexpr auto Kio = kibi<octet>;
-inline constexpr auto Mio = mebi<octet>;
-inline constexpr auto Gio = gibi<octet>;
-inline constexpr auto Tio = tebi<octet>;
-inline constexpr auto Pio = pebi<octet>;
-inline constexpr auto Eio = exbi<octet>;
+constexpr auto Kio = kibi<octet>;
+constexpr auto Mio = mebi<octet>;
+constexpr auto Gio = gibi<octet>;
+constexpr auto Tio = tebi<octet>;
+constexpr auto Pio = pebi<octet>;
+constexpr auto Eio = exbi<octet>;
 
 // byte
-inline constexpr auto B = byte;
+constexpr auto B = byte;
 
-inline constexpr auto kB = si::kilo<byte>;
-inline constexpr auto MB = si::mega<byte>;
-inline constexpr auto GB = si::giga<byte>;
-inline constexpr auto TB = si::tera<byte>;
-inline constexpr auto PB = si::peta<byte>;
-inline constexpr auto EB = si::exa<byte>;
-inline constexpr auto ZB = si::zetta<byte>;
-inline constexpr auto YB = si::yotta<byte>;
-inline constexpr auto RB = si::ronna<byte>;
-inline constexpr auto QB = si::quetta<byte>;
+constexpr auto kB = si::kilo<byte>;
+constexpr auto MB = si::mega<byte>;
+constexpr auto GB = si::giga<byte>;
+constexpr auto TB = si::tera<byte>;
+constexpr auto PB = si::peta<byte>;
+constexpr auto EB = si::exa<byte>;
+constexpr auto ZB = si::zetta<byte>;
+constexpr auto YB = si::yotta<byte>;
+constexpr auto RB = si::ronna<byte>;
+constexpr auto QB = si::quetta<byte>;
 
-inline constexpr auto KiB = kibi<byte>;
-inline constexpr auto MiB = mebi<byte>;
-inline constexpr auto GiB = gibi<byte>;
-inline constexpr auto TiB = tebi<byte>;
-inline constexpr auto PiB = pebi<byte>;
-inline constexpr auto EiB = exbi<byte>;
+constexpr auto KiB = kibi<byte>;
+constexpr auto MiB = mebi<byte>;
+constexpr auto GiB = gibi<byte>;
+constexpr auto TiB = tebi<byte>;
+constexpr auto PiB = pebi<byte>;
+constexpr auto EiB = exbi<byte>;
 
 // baud
-inline constexpr auto Bd = baud;
-inline constexpr auto kBd = si::kilo<baud>;
-inline constexpr auto MBd = si::mega<baud>;
-inline constexpr auto GBd = si::giga<baud>;
-inline constexpr auto TBd = si::tera<baud>;
-inline constexpr auto PBd = si::peta<baud>;
-inline constexpr auto EBd = si::exa<baud>;
-inline constexpr auto ZBd = si::zetta<baud>;
-inline constexpr auto YBd = si::yotta<baud>;
-inline constexpr auto RBd = si::ronna<baud>;
-inline constexpr auto QBd = si::quetta<baud>;
+constexpr auto Bd = baud;
+constexpr auto kBd = si::kilo<baud>;
+constexpr auto MBd = si::mega<baud>;
+constexpr auto GBd = si::giga<baud>;
+constexpr auto TBd = si::tera<baud>;
+constexpr auto PBd = si::peta<baud>;
+constexpr auto EBd = si::exa<baud>;
+constexpr auto ZBd = si::zetta<baud>;
+constexpr auto YBd = si::yotta<baud>;
+constexpr auto RBd = si::ronna<baud>;
+constexpr auto QBd = si::quetta<baud>;
 
 // erlang
 // TODO do we need prefixed versions of Erlang?
-inline constexpr auto E = erlang;
+constexpr auto E = erlang;
 
 }  // namespace mp_units::iec80000::unit_symbols
diff --git a/src/systems/include/mp-units/systems/iec80000/units.h b/src/systems/include/mp-units/systems/iec80000/units.h
index 4d1ee098..41f28c5f 100644
--- a/src/systems/include/mp-units/systems/iec80000/units.h
+++ b/src/systems/include/mp-units/systems/iec80000/units.h
@@ -34,11 +34,11 @@ MP_UNITS_EXPORT
 namespace mp_units::iec80000 {
 
 // clang-format off
-inline constexpr struct erlang final : named_unit<"E", kind_of<traffic_intensity>> {} erlang;
-inline constexpr struct bit final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
-inline constexpr struct octet final : named_unit<"o", mag<8> * bit> {} octet;
-inline constexpr struct byte final : named_unit<"B", mag<8> * bit> {} byte;
-inline constexpr struct baud final : named_unit<"Bd", one / si::second, kind_of<modulation_rate>> {} baud;
+constexpr struct erlang final : named_unit<"E", kind_of<traffic_intensity>> {} erlang;
+constexpr struct bit final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
+constexpr struct octet final : named_unit<"o", mag<8> * bit> {} octet;
+constexpr struct byte final : named_unit<"B", mag<8> * bit> {} byte;
+constexpr struct baud final : named_unit<"Bd", one / si::second, kind_of<modulation_rate>> {} baud;
 // clang-format on
 
 }  // namespace mp_units::iec80000
diff --git a/src/systems/include/mp-units/systems/imperial.h b/src/systems/include/mp-units/systems/imperial.h
index 8ba61e05..8c80ce56 100644
--- a/src/systems/include/mp-units/systems/imperial.h
+++ b/src/systems/include/mp-units/systems/imperial.h
@@ -39,67 +39,67 @@ using namespace international;
 
 // clang-format off
 // https://en.wikipedia.org/wiki/Imperial_units#Length
-inline constexpr struct hand final : named_unit<"hh", mag_ratio<1, 3> * foot> {} hand;
-inline constexpr struct barleycorn final : named_unit<"Bc", mag_ratio<1, 3> * inch> {} barleycorn;
-inline constexpr struct thou final : named_unit<"th", mag_ratio<1, 12'000> * foot> {} thou;
-inline constexpr struct chain final : named_unit<"ch", mag<22> * yard> {} chain;
-inline constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
+constexpr struct hand final : named_unit<"hh", mag_ratio<1, 3> * foot> {} hand;
+constexpr struct barleycorn final : named_unit<"Bc", mag_ratio<1, 3> * inch> {} barleycorn;
+constexpr struct thou final : named_unit<"th", mag_ratio<1, 12'000> * foot> {} thou;
+constexpr struct chain final : named_unit<"ch", mag<22> * yard> {} chain;
+constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
 
 // maritime units
-inline constexpr struct cable final : named_unit<"cb", mag_ratio<1, 10> * nautical_mile> {} cable;
-inline constexpr struct fathom final : named_unit<"ftm", mag_ratio<1, 1000> * nautical_mile> {} fathom;
+constexpr struct cable final : named_unit<"cb", mag_ratio<1, 10> * nautical_mile> {} cable;
+constexpr struct fathom final : named_unit<"ftm", mag_ratio<1, 1000> * nautical_mile> {} fathom;
 
 // survey
-inline constexpr struct link final : named_unit<"li", mag_ratio<1, 100> * chain> {} link;
-inline constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
+constexpr struct link final : named_unit<"li", mag_ratio<1, 100> * chain> {} link;
+constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
 
 // https://en.wikipedia.org/wiki/Imperial_units#Area
-inline constexpr struct perch final : named_unit<"perch", square(rod)> {} perch;
-inline constexpr struct rood final : named_unit<"rood", mag<40> * perch> {} rood;
-inline constexpr struct acre final : named_unit<"acre", mag<4> * rood> {} acre;
+constexpr struct perch final : named_unit<"perch", square(rod)> {} perch;
+constexpr struct rood final : named_unit<"rood", mag<40> * perch> {} rood;
+constexpr struct acre final : named_unit<"acre", mag<4> * rood> {} acre;
 
 // https://en.wikipedia.org/wiki/Imperial_units#Volume
-inline constexpr struct gallon final : named_unit<"gal", mag_ratio<454'609, 100'000> * si::litre> {} gallon;
-inline constexpr struct quart final : named_unit<"qt", mag_ratio<1, 4> * gallon> {} quart;
-inline constexpr struct pint final : named_unit<"pt", mag_ratio<1, 2> * quart> {} pint;
-inline constexpr struct gill final : named_unit<"gi", mag_ratio<1, 4> * pint> {} gill;
-inline constexpr struct fluid_ounce final : named_unit<"fl oz", mag_ratio<1, 5> * gill> {} fluid_ounce;
+constexpr struct gallon final : named_unit<"gal", mag_ratio<454'609, 100'000> * si::litre> {} gallon;
+constexpr struct quart final : named_unit<"qt", mag_ratio<1, 4> * gallon> {} quart;
+constexpr struct pint final : named_unit<"pt", mag_ratio<1, 2> * quart> {} pint;
+constexpr struct gill final : named_unit<"gi", mag_ratio<1, 4> * pint> {} gill;
+constexpr struct fluid_ounce final : named_unit<"fl oz", mag_ratio<1, 5> * gill> {} fluid_ounce;
 
 // https://en.wikipedia.org/wiki/Avoirdupois_system#Post-Elizabethan_units
-inline constexpr auto drachm = dram;
-inline constexpr struct stone final : named_unit<"st", mag<14> * pound> {} stone;
-inline constexpr struct quarter final : named_unit<"qr", mag<2> * stone> {} quarter;
-inline constexpr struct long_hundredweight final : named_unit<"cwt", mag<8> * stone> {} long_hundredweight;
-inline constexpr struct ton final : named_unit<"t", mag<2'240> * pound> {} ton;
-inline constexpr auto long_ton = ton;
+constexpr auto drachm = dram;
+constexpr struct stone final : named_unit<"st", mag<14> * pound> {} stone;
+constexpr struct quarter final : named_unit<"qr", mag<2> * stone> {} quarter;
+constexpr struct long_hundredweight final : named_unit<"cwt", mag<8> * stone> {} long_hundredweight;
+constexpr struct ton final : named_unit<"t", mag<2'240> * pound> {} ton;
+constexpr auto long_ton = ton;
 // clang-format on
 
 namespace unit_symbols {
 
 using namespace international::unit_symbols;
 
-inline constexpr auto hh = hand;
-inline constexpr auto Bc = barleycorn;
-inline constexpr auto th = thou;
-inline constexpr auto ch = chain;
-inline constexpr auto fur = furlong;
+constexpr auto hh = hand;
+constexpr auto Bc = barleycorn;
+constexpr auto th = thou;
+constexpr auto ch = chain;
+constexpr auto fur = furlong;
 
-inline constexpr auto cb = cable;
-inline constexpr auto ftm = fathom;
+constexpr auto cb = cable;
+constexpr auto ftm = fathom;
 
-inline constexpr auto li = link;
-inline constexpr auto rd = rod;
+constexpr auto li = link;
+constexpr auto rd = rod;
 
-inline constexpr auto gal = gallon;
-inline constexpr auto qt = quart;
-inline constexpr auto pt = pint;
-inline constexpr auto gi = gill;
-inline constexpr auto fl_oz = fluid_ounce;
+constexpr auto gal = gallon;
+constexpr auto qt = quart;
+constexpr auto pt = pint;
+constexpr auto gi = gill;
+constexpr auto fl_oz = fluid_ounce;
 
-inline constexpr auto st = stone;
-inline constexpr auto qr = quarter;
-inline constexpr auto cwt = long_hundredweight;
-inline constexpr auto t = ton;
+constexpr auto st = stone;
+constexpr auto qr = quarter;
+constexpr auto cwt = long_hundredweight;
+constexpr auto t = ton;
 
 }  // namespace unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/international.h b/src/systems/include/mp-units/systems/international.h
index 1d5141f6..206e3c7e 100644
--- a/src/systems/include/mp-units/systems/international.h
+++ b/src/systems/include/mp-units/systems/international.h
@@ -37,72 +37,72 @@ namespace mp_units::international {
 
 // clang-format off
 // mass
-inline constexpr struct pound final : named_unit<"lb", mag_ratio<45'359'237, 100'000'000> * si::kilogram> {} pound;
-inline constexpr struct ounce final : named_unit<"oz", mag_ratio<1, 16> * pound> {} ounce;
-inline constexpr struct dram final : named_unit<"dr", mag_ratio<1, 16> * ounce> {} dram;
-inline constexpr struct grain final : named_unit<"gr", mag_ratio<1, 7'000> * pound> {} grain;
+constexpr struct pound final : named_unit<"lb", mag_ratio<45'359'237, 100'000'000> * si::kilogram> {} pound;
+constexpr struct ounce final : named_unit<"oz", mag_ratio<1, 16> * pound> {} ounce;
+constexpr struct dram final : named_unit<"dr", mag_ratio<1, 16> * ounce> {} dram;
+constexpr struct grain final : named_unit<"gr", mag_ratio<1, 7'000> * pound> {} grain;
 
 // length
 // https://en.wikipedia.org/wiki/United_States_customary_units#Length
-inline constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
-inline constexpr struct foot final : named_unit<"ft", mag_ratio<1, 3> * yard> {} foot;
-inline constexpr struct inch final : named_unit<"in", mag_ratio<1, 12> * foot> {} inch;
-inline constexpr struct pica final : named_unit<"P", mag_ratio<1, 6> * inch> {} pica;
-inline constexpr struct point final : named_unit<"p", mag_ratio<1, 12> * pica> {} point;
-inline constexpr struct mil final : named_unit<"mil", mag_ratio<1, 1'000> * inch> {} mil;
-inline constexpr struct twip final : named_unit<"twip", mag_ratio<1, 20> * point> {} twip;
-inline constexpr struct mile final : named_unit<"mi", mag<1760> * yard> {} mile;
-inline constexpr struct league final : named_unit<"le", mag<3> * mile> {} league;
+constexpr struct yard final : named_unit<"yd", mag_ratio<9'144, 10'000> * si::metre> {} yard;
+constexpr struct foot final : named_unit<"ft", mag_ratio<1, 3> * yard> {} foot;
+constexpr struct inch final : named_unit<"in", mag_ratio<1, 12> * foot> {} inch;
+constexpr struct pica final : named_unit<"P", mag_ratio<1, 6> * inch> {} pica;
+constexpr struct point final : named_unit<"p", mag_ratio<1, 12> * pica> {} point;
+constexpr struct mil final : named_unit<"mil", mag_ratio<1, 1'000> * inch> {} mil;
+constexpr struct twip final : named_unit<"twip", mag_ratio<1, 20> * point> {} twip;
+constexpr struct mile final : named_unit<"mi", mag<1760> * yard> {} mile;
+constexpr struct league final : named_unit<"le", mag<3> * mile> {} league;
 
-inline constexpr struct nautical_mile final : named_unit<"nmi", mag<1852> * si::metre> {} nautical_mile;
+constexpr struct nautical_mile final : named_unit<"nmi", mag<1852> * si::metre> {} nautical_mile;
 
 // speed
-inline constexpr struct knot final : named_unit<"kn", nautical_mile / si::hour> {} knot;
+constexpr struct knot final : named_unit<"kn", nautical_mile / si::hour> {} knot;
 
 // force
 // https://en.wikipedia.org/wiki/Poundal
-inline constexpr struct poundal final : named_unit<"pdl", pound * foot / square(si::second)> {} poundal;
+constexpr struct poundal final : named_unit<"pdl", pound * foot / square(si::second)> {} poundal;
 
 // https://en.wikipedia.org/wiki/Pound_(force)
-inline constexpr struct pound_force final : named_unit<"lbf", pound * si::standard_gravity> {} pound_force;
+constexpr struct pound_force final : named_unit<"lbf", pound * si::standard_gravity> {} pound_force;
 
 // https://en.wikipedia.org/wiki/Kip_(unit),
-inline constexpr auto kip = si::kilo<pound_force>;
+constexpr auto kip = si::kilo<pound_force>;
 
 // pressure
-inline constexpr struct psi final : named_unit<"psi", pound_force / square(inch)> {} psi;
+constexpr struct psi final : named_unit<"psi", pound_force / square(inch)> {} psi;
 
 // power
 // https://en.wikipedia.org/wiki/Horsepower#Definitions
-inline constexpr struct mechanical_horsepower final : named_unit<"hp(I)", mag<33'000> * foot * pound_force / si::minute> {} mechanical_horsepower;
+constexpr struct mechanical_horsepower final : named_unit<"hp(I)", mag<33'000> * foot * pound_force / si::minute> {} mechanical_horsepower;
 // clang-format on
 
 
 namespace unit_symbols {
 
-inline constexpr auto lb = pound;
-inline constexpr auto oz = ounce;
-inline constexpr auto dr = dram;
-inline constexpr auto gr = grain;
+constexpr auto lb = pound;
+constexpr auto oz = ounce;
+constexpr auto dr = dram;
+constexpr auto gr = grain;
 
-inline constexpr auto yd = yard;
-inline constexpr auto ft = foot;
-inline constexpr auto in = inch;
-inline constexpr auto P = pica;
-inline constexpr auto p = point;
-inline constexpr auto mi = mile;
-inline constexpr auto le = league;
+constexpr auto yd = yard;
+constexpr auto ft = foot;
+constexpr auto in = inch;
+constexpr auto P = pica;
+constexpr auto p = point;
+constexpr auto mi = mile;
+constexpr auto le = league;
 
-inline constexpr auto nmi = nautical_mile;
+constexpr auto nmi = nautical_mile;
 
-inline constexpr auto kn = knot;
-inline constexpr auto kt = knot;
-inline constexpr auto mph = mile / si::hour;
+constexpr auto kn = knot;
+constexpr auto kt = knot;
+constexpr auto mph = mile / si::hour;
 
-inline constexpr auto pdl = poundal;
-inline constexpr auto lbf = pound_force;
+constexpr auto pdl = poundal;
+constexpr auto lbf = pound_force;
 
-inline constexpr auto hp = mechanical_horsepower;
+constexpr auto hp = mechanical_horsepower;
 
 }  // namespace unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/isq/base_quantities.h b/src/systems/include/mp-units/systems/isq/base_quantities.h
index c7f4f337..7e9ea017 100644
--- a/src/systems/include/mp-units/systems/isq/base_quantities.h
+++ b/src/systems/include/mp-units/systems/isq/base_quantities.h
@@ -35,20 +35,20 @@ namespace mp_units::isq {
 
 // clang-format off
 // dimensions of base quantities
-inline constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
-inline constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
-inline constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
-inline constexpr struct dim_electric_current final : base_dimension<"I"> {} dim_electric_current;
-inline constexpr struct dim_thermodynamic_temperature final : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
-inline constexpr struct dim_amount_of_substance final : base_dimension<"N"> {} dim_amount_of_substance;
-inline constexpr struct dim_luminous_intensity final : base_dimension<"J"> {} dim_luminous_intensity;
+constexpr struct dim_length final : base_dimension<"L"> {} dim_length;
+constexpr struct dim_mass final : base_dimension<"M"> {} dim_mass;
+constexpr struct dim_time final : base_dimension<"T"> {} dim_time;
+constexpr struct dim_electric_current final : base_dimension<"I"> {} dim_electric_current;
+constexpr struct dim_thermodynamic_temperature final : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
+constexpr struct dim_amount_of_substance final : base_dimension<"N"> {} dim_amount_of_substance;
+constexpr struct dim_luminous_intensity final : base_dimension<"J"> {} dim_luminous_intensity;
 // clang-format on
 
 // base quantities
 QUANTITY_SPEC(length, dim_length);
 QUANTITY_SPEC(mass, dim_mass);
 QUANTITY_SPEC(time, dim_time);
-inline constexpr auto duration = time;
+constexpr auto duration = time;
 QUANTITY_SPEC(electric_current, dim_electric_current);
 QUANTITY_SPEC(thermodynamic_temperature, dim_thermodynamic_temperature);
 QUANTITY_SPEC(amount_of_substance, dim_amount_of_substance);
diff --git a/src/systems/include/mp-units/systems/isq/electromagnetism.h b/src/systems/include/mp-units/systems/isq/electromagnetism.h
index bdb5bc8b..84f556ba 100644
--- a/src/systems/include/mp-units/systems/isq/electromagnetism.h
+++ b/src/systems/include/mp-units/systems/isq/electromagnetism.h
@@ -39,25 +39,25 @@ namespace mp_units::isq {
 
 QUANTITY_SPEC(electric_charge, electric_current* time);
 QUANTITY_SPEC(electric_charge_density, electric_charge / volume);
-inline constexpr auto volume_electric_charge = electric_charge_density;
+constexpr auto volume_electric_charge = electric_charge_density;
 QUANTITY_SPEC(surface_density_of_electric_charge, electric_charge / area);
-inline constexpr auto areic_electric_charge = surface_density_of_electric_charge;
+constexpr auto areic_electric_charge = surface_density_of_electric_charge;
 QUANTITY_SPEC(linear_density_of_electric_charge, electric_charge / length);
-inline constexpr auto lineic_electric_charge = linear_density_of_electric_charge;
+constexpr auto lineic_electric_charge = linear_density_of_electric_charge;
 QUANTITY_SPEC(electric_dipole_moment, electric_charge* position_vector);     // vector
 QUANTITY_SPEC(electric_polarization, electric_dipole_moment / volume);       // vector
 QUANTITY_SPEC(electric_current_density, electric_charge_density* velocity);  // vector
-inline constexpr auto areic_electric_current = electric_current_density;
+constexpr auto areic_electric_current = electric_current_density;
 QUANTITY_SPEC(linear_electric_current_density, surface_density_of_electric_charge* velocity);  // vector
-inline constexpr auto lineic_electric_current = linear_electric_current_density;
+constexpr auto lineic_electric_current = linear_electric_current_density;
 QUANTITY_SPEC(electric_field_strength, force / electric_charge);  // vector
 QUANTITY_SPEC(electric_potential, electric_field_strength* length,
               quantity_character::scalar);  // TODO what is a correct equation here?
 QUANTITY_SPEC(electric_potential_difference, electric_potential, quantity_character::scalar);
 QUANTITY_SPEC(voltage, electric_potential);
-inline constexpr auto electric_tension = voltage;
+constexpr auto electric_tension = voltage;
 QUANTITY_SPEC(electric_flux_density, electric_polarization);  // vector
-inline constexpr auto electric_displacement = electric_flux_density;
+constexpr auto electric_displacement = electric_flux_density;
 QUANTITY_SPEC(capacitance, electric_charge / voltage);
 // TODO how to calculate an argument of a vector product?
 QUANTITY_SPEC(magnetic_flux_density, force / (electric_charge * velocity), quantity_character::vector);
@@ -66,13 +66,13 @@ QUANTITY_SPEC(magnetic_vector_potential,
 QUANTITY_SPEC(linked_flux, magnetic_vector_potential* displacement, quantity_character::scalar);
 QUANTITY_SPEC(magnetic_constant,
               electric_potential* time / (electric_current * length));  // TODO what is a correct equation here?
-inline constexpr auto permeability_of_vacuum = magnetic_constant;
+constexpr auto permeability_of_vacuum = magnetic_constant;
 QUANTITY_SPEC(phase_speed_of_electromagnetic_waves, angular_frequency / angular_wavenumber);
 QUANTITY_SPEC(speed_of_light_in_vacuum, speed);
-inline constexpr auto light_speed_in_vacuum = speed_of_light_in_vacuum;
-inline constexpr auto luminal_speed = speed_of_light_in_vacuum;
+constexpr auto light_speed_in_vacuum = speed_of_light_in_vacuum;
+constexpr auto luminal_speed = speed_of_light_in_vacuum;
 QUANTITY_SPEC(electric_constant, inverse(magnetic_constant* pow<2>(speed_of_light_in_vacuum)));
-inline constexpr auto permittivity_of_vacuum = electric_constant;
+constexpr auto permittivity_of_vacuum = electric_constant;
 QUANTITY_SPEC(permittivity, electric_flux_density / electric_field_strength, quantity_character::scalar);
 QUANTITY_SPEC(relative_permittivity, dimensionless, permittivity / electric_constant);
 QUANTITY_SPEC(electric_susceptibility, dimensionless,
@@ -84,10 +84,10 @@ QUANTITY_SPEC(total_current, electric_current);
 QUANTITY_SPEC(total_current_density, electric_current_density);  // vector
 QUANTITY_SPEC(magnetic_flux, magnetic_flux_density* area, quantity_character::scalar);
 QUANTITY_SPEC(magnetic_moment, electric_current* area, quantity_character::vector);
-inline constexpr auto magnetic_area_moment = magnetic_moment;
+constexpr auto magnetic_area_moment = magnetic_moment;
 QUANTITY_SPEC(magnetization, magnetic_moment / volume);  // vector
 QUANTITY_SPEC(magnetic_field_strength, magnetization);   // vector
-inline constexpr auto magnetizing_field = magnetic_field_strength;
+constexpr auto magnetizing_field = magnetic_field_strength;
 QUANTITY_SPEC(permeability, magnetic_flux_density / magnetic_field_strength, quantity_character::scalar);
 QUANTITY_SPEC(relative_permeability, dimensionless, permeability / magnetic_constant);
 QUANTITY_SPEC(magnetic_susceptibility, dimensionless, magnetization / magnetic_field_strength,
@@ -97,10 +97,10 @@ QUANTITY_SPEC(magnetic_dipole_moment, magnetic_constant* magnetic_moment);  // v
 QUANTITY_SPEC(coercivity, magnetic_field_strength, quantity_character::scalar);
 QUANTITY_SPEC(electromagnetic_energy_density, electric_field_strength* electric_flux_density,
               quantity_character::scalar);
-inline constexpr auto volumic_electromagnetic_energy = electromagnetic_energy_density;
+constexpr auto volumic_electromagnetic_energy = electromagnetic_energy_density;
 QUANTITY_SPEC(Poynting_vector, electric_field_strength* magnetic_field_strength);  // vector
 QUANTITY_SPEC(source_voltage, voltage);
-inline constexpr auto source_tension = source_voltage;
+constexpr auto source_tension = source_voltage;
 QUANTITY_SPEC(scalar_magnetic_potential, electric_current, magnetic_field_strength* length,
               quantity_character::scalar);  // TODO what is a correct equation here?
 QUANTITY_SPEC(magnetic_tension, electric_current, magnetic_field_strength* position_vector, quantity_character::scalar);
@@ -111,26 +111,26 @@ QUANTITY_SPEC(number_of_turns_in_a_winding, dimensionless);
 QUANTITY_SPEC(reluctance, magnetic_tension / magnetic_flux);
 QUANTITY_SPEC(permeance, inverse(reluctance));
 QUANTITY_SPEC(inductance, linked_flux / electric_current);
-inline constexpr auto self_inductance = inductance;
+constexpr auto self_inductance = inductance;
 QUANTITY_SPEC(mutual_inductance, linked_flux / electric_current);
 QUANTITY_SPEC(coupling_factor, dimensionless, mutual_inductance / pow<1, 2>(pow<2>(self_inductance)));
 QUANTITY_SPEC(leakage_factor, dimensionless, pow<2>(coupling_factor));
 QUANTITY_SPEC(conductivity, electric_current_density / electric_field_strength, quantity_character::scalar);
 QUANTITY_SPEC(resistivity, inverse(conductivity));
 QUANTITY_SPEC(electromagnetism_power, power, voltage* electric_current);
-inline constexpr auto instantaneous_power = electromagnetism_power;
+constexpr auto instantaneous_power = electromagnetism_power;
 QUANTITY_SPEC(resistance, voltage / electric_current);
 QUANTITY_SPEC(conductance, inverse(resistance));
 QUANTITY_SPEC(phase_difference, phase_angle);
 QUANTITY_SPEC(electric_current_phasor, electric_current);
 QUANTITY_SPEC(voltage_phasor, voltage);
 QUANTITY_SPEC(impedance, voltage_phasor / electric_current_phasor);
-inline constexpr auto complex_impedance = impedance;
+constexpr auto complex_impedance = impedance;
 QUANTITY_SPEC(resistance_to_alternating_current, impedance);
 QUANTITY_SPEC(reactance, impedance);
 QUANTITY_SPEC(modulus_of_impedance, impedance);
 QUANTITY_SPEC(admittance, inverse(impedance));
-inline constexpr auto complex_admittance = admittance;
+constexpr auto complex_admittance = admittance;
 QUANTITY_SPEC(conductance_for_alternating_current, admittance);
 QUANTITY_SPEC(susceptance, admittance);
 QUANTITY_SPEC(modulus_of_admittance, admittance);
diff --git a/src/systems/include/mp-units/systems/isq/light_and_radiation.h b/src/systems/include/mp-units/systems/isq/light_and_radiation.h
index bfca2dbf..bb5b772d 100644
--- a/src/systems/include/mp-units/systems/isq/light_and_radiation.h
+++ b/src/systems/include/mp-units/systems/isq/light_and_radiation.h
@@ -45,9 +45,9 @@ QUANTITY_SPEC(radiant_energy_density, radiant_energy / volume);
 QUANTITY_SPEC(spectral_radiant_energy_density_in_terms_of_wavelength, radiant_energy_density / wavelength);
 QUANTITY_SPEC(spectral_radiant_energy_density_in_terms_of_wavenumber, radiant_energy_density / wavenumber);
 QUANTITY_SPEC(radiant_flux, power, radiant_energy / time);
-inline constexpr auto radiant_power = radiant_flux;
+constexpr auto radiant_power = radiant_flux;
 QUANTITY_SPEC(spectral_radiant_flux, radiant_flux / wavelength);
-inline constexpr auto spectral_radiant_power = spectral_radiant_flux;
+constexpr auto spectral_radiant_power = spectral_radiant_flux;
 QUANTITY_SPEC(radiant_intensity, radiant_flux / solid_angular_measure);
 QUANTITY_SPEC(spectral_radiant_intensity, radiant_intensity / wavelength);
 QUANTITY_SPEC(radiance, radiant_intensity / area);
diff --git a/src/systems/include/mp-units/systems/isq/mechanics.h b/src/systems/include/mp-units/systems/isq/mechanics.h
index 41157143..4de54232 100644
--- a/src/systems/include/mp-units/systems/isq/mechanics.h
+++ b/src/systems/include/mp-units/systems/isq/mechanics.h
@@ -37,24 +37,24 @@ MP_UNITS_EXPORT
 namespace mp_units::isq {
 
 QUANTITY_SPEC(mass_density, mass / volume);
-inline constexpr auto density = mass_density;
+constexpr auto density = mass_density;
 QUANTITY_SPEC(specific_volume, inverse(mass_density));
 QUANTITY_SPEC(relative_mass_density, mass_density / mass_density);
-inline constexpr auto relative_density = relative_mass_density;
+constexpr auto relative_density = relative_mass_density;
 QUANTITY_SPEC(surface_mass_density, mass / area);
-inline constexpr auto surface_density = surface_mass_density;
+constexpr auto surface_density = surface_mass_density;
 QUANTITY_SPEC(linear_mass_density, mass / length);
-inline constexpr auto linear_density = linear_mass_density;
+constexpr auto linear_density = linear_mass_density;
 QUANTITY_SPEC(momentum, mass* velocity);                        // vector
 QUANTITY_SPEC(force, mass* acceleration);                       // vector  // TODO what is a correct equation here?
 QUANTITY_SPEC(weight, force, mass* acceleration_of_free_fall);  // vector  // differs from ISO 80000
 QUANTITY_SPEC(static_friction_force, force);                    // vector
-inline constexpr auto static_friction = static_friction_force;
+constexpr auto static_friction = static_friction_force;
 QUANTITY_SPEC(kinetic_friction_force, force);  // vector
-inline constexpr auto dynamic_friction_force = kinetic_friction_force;
+constexpr auto dynamic_friction_force = kinetic_friction_force;
 QUANTITY_SPEC(rolling_resistance, force);  // vector
-inline constexpr auto rolling_drag = rolling_resistance;
-inline constexpr auto rolling_friction_force = rolling_resistance;
+constexpr auto rolling_drag = rolling_resistance;
+constexpr auto rolling_friction_force = rolling_resistance;
 QUANTITY_SPEC(drag_force, force);                            // vector
 QUANTITY_SPEC(impulse, force* time);                         // vector
 QUANTITY_SPEC(angular_momentum, position_vector* momentum);  // vector
@@ -73,24 +73,24 @@ QUANTITY_SPEC(shear_strain, dimensionless, displacement / thickness, quantity_ch
 QUANTITY_SPEC(relative_volume_strain, volume / volume);
 QUANTITY_SPEC(Poisson_number, dimensionless, width / length);
 QUANTITY_SPEC(modulus_of_elasticity, normal_stress / relative_linear_strain);
-inline constexpr auto Young_modulus = modulus_of_elasticity;
+constexpr auto Young_modulus = modulus_of_elasticity;
 QUANTITY_SPEC(modulus_of_rigidity, shear_stress / shear_strain);
-inline constexpr auto shear_modulus = modulus_of_rigidity;
+constexpr auto shear_modulus = modulus_of_rigidity;
 QUANTITY_SPEC(modulus_of_compression, pressure / relative_volume_strain);
-inline constexpr auto bulk_modulus = modulus_of_compression;
+constexpr auto bulk_modulus = modulus_of_compression;
 QUANTITY_SPEC(compressibility, inverse(volume) * (volume / pressure));
 QUANTITY_SPEC(second_axial_moment_of_area, pow<2>(radial_distance) * area);
 QUANTITY_SPEC(second_polar_moment_of_area, pow<2>(radial_distance) * area);
 QUANTITY_SPEC(section_modulus, second_axial_moment_of_area / radial_distance);
 QUANTITY_SPEC(static_friction_coefficient, dimensionless, static_friction_force / force, quantity_character::scalar);
-inline constexpr auto static_friction_factor = static_friction_coefficient;
-inline constexpr auto coefficient_of_static_friction = static_friction_coefficient;
+constexpr auto static_friction_factor = static_friction_coefficient;
+constexpr auto coefficient_of_static_friction = static_friction_coefficient;
 QUANTITY_SPEC(kinetic_friction_factor, dimensionless, kinetic_friction_force / force, quantity_character::scalar);
-inline constexpr auto dynamic_friction_factor = kinetic_friction_factor;
+constexpr auto dynamic_friction_factor = kinetic_friction_factor;
 QUANTITY_SPEC(rolling_resistance_factor, force / force, quantity_character::scalar);
 QUANTITY_SPEC(drag_coefficient, dimensionless, drag_force / (mass_density * pow<2>(speed) * area),
               quantity_character::scalar);
-inline constexpr auto drag_factor = drag_coefficient;
+constexpr auto drag_factor = drag_coefficient;
 QUANTITY_SPEC(dynamic_viscosity, shear_stress* length / velocity, quantity_character::scalar);
 QUANTITY_SPEC(kinematic_viscosity, dynamic_viscosity / mass_density);
 QUANTITY_SPEC(surface_tension, force / length, quantity_character::scalar);  // TODO what is a correct equation here?
@@ -100,7 +100,7 @@ QUANTITY_SPEC(mechanical_energy, energy);                               // diffe
 QUANTITY_SPEC(potential_energy, mechanical_energy);                     // differs from ISO 80000
 QUANTITY_SPEC(kinetic_energy, mechanical_energy, mass* pow<2>(speed));  // differs from ISO 80000
 QUANTITY_SPEC(mechanical_work, force* displacement, quantity_character::scalar);
-inline constexpr auto work = mechanical_work;
+constexpr auto work = mechanical_work;
 QUANTITY_SPEC(mechanical_efficiency, mechanical_power / mechanical_power);
 QUANTITY_SPEC(mass_flow, mass_density* velocity);  // vector
 QUANTITY_SPEC(mass_flow_rate, mass_flow* area, quantity_character::scalar);
diff --git a/src/systems/include/mp-units/systems/isq/si_quantities.h b/src/systems/include/mp-units/systems/isq/si_quantities.h
index 9486c3e3..a8b66c27 100644
--- a/src/systems/include/mp-units/systems/isq/si_quantities.h
+++ b/src/systems/include/mp-units/systems/isq/si_quantities.h
@@ -37,15 +37,15 @@ namespace mp_units::isq {
 
 // space and time
 QUANTITY_SPEC(width, length);
-inline constexpr auto breadth = width;
+constexpr auto breadth = width;
 QUANTITY_SPEC(radius, width);  // differs from ISO 80000
 QUANTITY_SPEC(path_length, length);
-inline constexpr auto arc_length = path_length;
+constexpr auto arc_length = path_length;
 QUANTITY_SPEC(area, pow<2>(length));
 QUANTITY_SPEC(angular_measure, dimensionless, arc_length / radius, is_kind);
 QUANTITY_SPEC(solid_angular_measure, dimensionless, area / pow<2>(radius), is_kind);
 QUANTITY_SPEC(period_duration, duration);
-inline constexpr auto period = period_duration;
+constexpr auto period = period_duration;
 QUANTITY_SPEC(frequency, inverse(period_duration));
 
 // mechanics
diff --git a/src/systems/include/mp-units/systems/isq/space_and_time.h b/src/systems/include/mp-units/systems/isq/space_and_time.h
index 2157a299..d24db136 100644
--- a/src/systems/include/mp-units/systems/isq/space_and_time.h
+++ b/src/systems/include/mp-units/systems/isq/space_and_time.h
@@ -36,8 +36,8 @@ MP_UNITS_EXPORT
 namespace mp_units::isq {
 
 QUANTITY_SPEC(height, length);
-inline constexpr auto depth = height;
-inline constexpr auto altitude = height;
+constexpr auto depth = height;
+constexpr auto altitude = height;
 QUANTITY_SPEC(thickness, width);
 QUANTITY_SPEC(diameter, width);
 QUANTITY_SPEC(distance, path_length);
@@ -48,7 +48,7 @@ QUANTITY_SPEC(radius_of_curvature, radius);
 QUANTITY_SPEC(curvature, inverse(radius_of_curvature));
 QUANTITY_SPEC(volume, pow<3>(length));
 QUANTITY_SPEC(rotational_displacement, angular_measure, path_length / radius);
-inline constexpr auto angular_displacement = rotational_displacement;
+constexpr auto angular_displacement = rotational_displacement;
 QUANTITY_SPEC(phase_angle, angular_measure);
 QUANTITY_SPEC(speed, length / time);                         // differs from ISO 80000
 QUANTITY_SPEC(velocity, speed, position_vector / duration);  // vector  // differs from ISO 80000
@@ -62,18 +62,18 @@ QUANTITY_SPEC(rotational_frequency, rotation / duration);
 QUANTITY_SPEC(angular_frequency, phase_angle / duration);
 QUANTITY_SPEC(wavelength, length);
 QUANTITY_SPEC(repetency, inverse(wavelength));
-inline constexpr auto wavenumber = repetency;
+constexpr auto wavenumber = repetency;
 QUANTITY_SPEC(wave_vector, repetency, quantity_character::vector);
 QUANTITY_SPEC(angular_repetency, inverse(wavelength));
-inline constexpr auto angular_wavenumber = angular_repetency;
+constexpr auto angular_wavenumber = angular_repetency;
 QUANTITY_SPEC(phase_velocity, angular_frequency / angular_repetency);
-inline constexpr auto phase_speed = phase_velocity;
+constexpr auto phase_speed = phase_velocity;
 QUANTITY_SPEC(group_velocity, angular_frequency / angular_repetency);
-inline constexpr auto group_speed = group_velocity;
+constexpr auto group_speed = group_velocity;
 QUANTITY_SPEC(damping_coefficient, inverse(time_constant));
 QUANTITY_SPEC(logarithmic_decrement, dimensionless, damping_coefficient* period_duration);
 QUANTITY_SPEC(attenuation, inverse(distance));
-inline constexpr auto extinction = attenuation;
+constexpr auto extinction = attenuation;
 QUANTITY_SPEC(phase_coefficient, phase_angle / path_length);
 QUANTITY_SPEC(propagation_coefficient, inverse(length));  // γ = α + iβ where α denotes attenuation
                                                           // and β the phase coefficient of a plane wave
diff --git a/src/systems/include/mp-units/systems/isq/thermodynamics.h b/src/systems/include/mp-units/systems/isq/thermodynamics.h
index aed8edf9..f5b72d90 100644
--- a/src/systems/include/mp-units/systems/isq/thermodynamics.h
+++ b/src/systems/include/mp-units/systems/isq/thermodynamics.h
@@ -46,7 +46,7 @@ QUANTITY_SPEC(isothermal_compressibility, inverse(volume) * (volume / pressure))
 QUANTITY_SPEC(isentropic_compressibility, inverse(volume) * (volume / pressure));  // TODO how to handle "negative" part
 // energy definition moved to mechanics
 QUANTITY_SPEC(heat, energy);
-inline constexpr auto amount_of_heat = heat;
+constexpr auto amount_of_heat = heat;
 QUANTITY_SPEC(latent_heat, heat);  // TODO what is a correct equation here?
 QUANTITY_SPEC(heat_flow_rate, heat / time);
 QUANTITY_SPEC(density_of_heat_flow_rate, heat_flow_rate / area);
@@ -54,7 +54,7 @@ QUANTITY_SPEC(thermal_conductivity, density_of_heat_flow_rate*(length / thermody
 QUANTITY_SPEC(coefficient_of_heat_transfer, density_of_heat_flow_rate / thermodynamic_temperature);
 QUANTITY_SPEC(surface_coefficient_of_heat_transfer, density_of_heat_flow_rate / thermodynamic_temperature);
 QUANTITY_SPEC(thermal_insulance, inverse(coefficient_of_heat_transfer));
-inline constexpr auto coefficient_of_thermal_insulance = thermal_insulance;
+constexpr auto coefficient_of_thermal_insulance = thermal_insulance;
 QUANTITY_SPEC(thermal_resistance, thermodynamic_temperature / heat_flow_rate);
 QUANTITY_SPEC(thermal_conductance, inverse(thermal_resistance));
 QUANTITY_SPEC(heat_capacity, heat / thermodynamic_temperature);
@@ -67,24 +67,24 @@ QUANTITY_SPEC(ratio_of_specific_heat_capacities, dimensionless,
               specific_heat_capacity_at_constant_pressure / specific_heat_capacity_at_constant_volume);
 QUANTITY_SPEC(isentropic_exponent,
               volume / pressure * (pressure / volume));  // TODO how to handle "negative" part
-inline constexpr auto isentropic_expansion_factor = isentropic_exponent;
+constexpr auto isentropic_expansion_factor = isentropic_exponent;
 QUANTITY_SPEC(entropy, kinetic_energy / thermodynamic_temperature);
 QUANTITY_SPEC(specific_entropy, entropy / mass);
 QUANTITY_SPEC(enthalpy, energy);           // differs from ISO 80000
 QUANTITY_SPEC(internal_energy, enthalpy);  // differs from ISO 80000
-inline constexpr auto thermodynamic_energy = internal_energy;
+constexpr auto thermodynamic_energy = internal_energy;
 QUANTITY_SPEC(Helmholtz_energy, internal_energy);
-inline constexpr auto Helmholtz_function = Helmholtz_energy;
+constexpr auto Helmholtz_function = Helmholtz_energy;
 QUANTITY_SPEC(Gibbs_energy, enthalpy);
-inline constexpr auto Gibbs_function = Gibbs_energy;
+constexpr auto Gibbs_function = Gibbs_energy;
 QUANTITY_SPEC(specific_energy, energy / mass);
 QUANTITY_SPEC(specific_internal_energy, internal_energy / mass);
-inline constexpr auto specific_thermodynamic_energy = specific_internal_energy;
+constexpr auto specific_thermodynamic_energy = specific_internal_energy;
 QUANTITY_SPEC(specific_enthalpy, enthalpy / mass);
 QUANTITY_SPEC(specific_Helmholtz_energy, Helmholtz_energy / mass);
-inline constexpr auto specific_Helmholtz_function = specific_Helmholtz_energy;
+constexpr auto specific_Helmholtz_function = specific_Helmholtz_energy;
 QUANTITY_SPEC(specific_Gibbs_energy, Gibbs_energy / mass);
-inline constexpr auto specific_Gibbs_function = specific_Gibbs_energy;
+constexpr auto specific_Gibbs_function = specific_Gibbs_energy;
 QUANTITY_SPEC(Massieu_function, Helmholtz_energy / thermodynamic_temperature);  // TODO how to handle "negative" part
 QUANTITY_SPEC(Planck_function, Gibbs_energy / thermodynamic_temperature);       // TODO how to handle "negative" part
 QUANTITY_SPEC(Joule_Thomson_coefficient, thermodynamic_temperature / pressure);
diff --git a/src/systems/include/mp-units/systems/isq_angle.h b/src/systems/include/mp-units/systems/isq_angle.h
index bf306d93..69584b94 100644
--- a/src/systems/include/mp-units/systems/isq_angle.h
+++ b/src/systems/include/mp-units/systems/isq_angle.h
@@ -43,7 +43,7 @@ using namespace isq;
 QUANTITY_SPEC(cotes_angle_constant, angular::angle);  // 1 rad
 QUANTITY_SPEC(angular_measure, angular::angle, cotes_angle_constant* arc_length / radius);
 QUANTITY_SPEC(rotational_displacement, angular::angle, cotes_angle_constant* path_length / radius);
-inline constexpr auto angular_displacement = rotational_displacement;
+constexpr auto angular_displacement = rotational_displacement;
 QUANTITY_SPEC(phase_angle, angular_measure);
 QUANTITY_SPEC(solid_angular_measure, pow<2>(cotes_angle_constant) * area / pow<2>(radius));
 QUANTITY_SPEC(angular_velocity, angular_displacement / duration, quantity_character::vector);
@@ -51,7 +51,7 @@ QUANTITY_SPEC(angular_acceleration, angular_velocity / duration);
 QUANTITY_SPEC(rotation, rotational_displacement);
 QUANTITY_SPEC(angular_frequency, phase_angle / duration);
 QUANTITY_SPEC(angular_repetency, cotes_angle_constant / wavelength);
-inline constexpr auto angular_wavenumber = angular_repetency;
+constexpr auto angular_wavenumber = angular_repetency;
 QUANTITY_SPEC(phase_coefficient, phase_angle / path_length);
 QUANTITY_SPEC(propagation_coefficient, cotes_angle_constant / length);
 QUANTITY_SPEC(angular_momentum, position_vector* momentum / cotes_angle_constant);  // vector
@@ -62,6 +62,6 @@ QUANTITY_SPEC(angular_impulse, moment_of_force* time);  // vector
 QUANTITY_SPEC(loss_angle, angular_measure);
 
 // constants
-inline constexpr auto cotes_angle = cotes_angle_constant[angular::radian];
+constexpr auto cotes_angle = cotes_angle_constant[angular::radian];
 
 }  // namespace mp_units::isq_angle
diff --git a/src/systems/include/mp-units/systems/natural.h b/src/systems/include/mp-units/systems/natural.h
index b5a65b63..23faf2db 100644
--- a/src/systems/include/mp-units/systems/natural.h
+++ b/src/systems/include/mp-units/systems/natural.h
@@ -38,28 +38,28 @@ namespace mp_units::natural {
 
 // clang-format off
 // units
-inline constexpr struct electronvolt final : named_unit<"eV"> {} electronvolt;
-inline constexpr auto gigaelectronvolt = si::giga<electronvolt>;
+constexpr struct electronvolt final : named_unit<"eV"> {} electronvolt;
+constexpr auto gigaelectronvolt = si::giga<electronvolt>;
 
 // system references
-inline constexpr struct time : system_reference<isq::time, inverse(gigaelectronvolt)> {} time;
-inline constexpr struct length : system_reference<isq::length, inverse(gigaelectronvolt)> {} length;
-inline constexpr struct mass : system_reference<isq::mass, gigaelectronvolt> {} mass;
-inline constexpr struct velocity : system_reference<isq::velocity, one> {} velocity;
-inline constexpr struct speed : system_reference<isq::speed, one> {} speed;
-inline constexpr struct acceleration : system_reference<isq::acceleration, gigaelectronvolt> {} acceleration;
-inline constexpr struct momentum : system_reference<isq::momentum, gigaelectronvolt> {} momentum;
-inline constexpr struct force : system_reference<isq::force, square(gigaelectronvolt)> {} force;
-inline constexpr struct energy : system_reference<isq::mechanical_energy, gigaelectronvolt> {} energy;
+constexpr struct time : system_reference<isq::time, inverse(gigaelectronvolt)> {} time;
+constexpr struct length : system_reference<isq::length, inverse(gigaelectronvolt)> {} length;
+constexpr struct mass : system_reference<isq::mass, gigaelectronvolt> {} mass;
+constexpr struct velocity : system_reference<isq::velocity, one> {} velocity;
+constexpr struct speed : system_reference<isq::speed, one> {} speed;
+constexpr struct acceleration : system_reference<isq::acceleration, gigaelectronvolt> {} acceleration;
+constexpr struct momentum : system_reference<isq::momentum, gigaelectronvolt> {} momentum;
+constexpr struct force : system_reference<isq::force, square(gigaelectronvolt)> {} force;
+constexpr struct energy : system_reference<isq::mechanical_energy, gigaelectronvolt> {} energy;
 // clang-format on
 
 // constants
-inline constexpr auto speed_of_light = speed[one];
+constexpr auto speed_of_light = speed[one];
 
 namespace unit_symbols {
 
-inline constexpr auto GeV = gigaelectronvolt;
-inline constexpr auto GeV2 = square(gigaelectronvolt);
+constexpr auto GeV = gigaelectronvolt;
+constexpr auto GeV2 = square(gigaelectronvolt);
 
 }  // namespace unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/si/chrono.h b/src/systems/include/mp-units/systems/si/chrono.h
index fa878269..abf15b51 100644
--- a/src/systems/include/mp-units/systems/si/chrono.h
+++ b/src/systems/include/mp-units/systems/si/chrono.h
@@ -93,7 +93,7 @@ struct chrono_point_origin_ final : absolute_point_origin<isq::time> {
   using clock = C;
 };
 MP_UNITS_EXPORT template<typename C>
-inline constexpr chrono_point_origin_<C> chrono_point_origin;
+constexpr chrono_point_origin_<C> chrono_point_origin;
 
 MP_UNITS_EXPORT_BEGIN
 
diff --git a/src/systems/include/mp-units/systems/si/constants.h b/src/systems/include/mp-units/systems/si/constants.h
index a43c871c..0e47105a 100644
--- a/src/systems/include/mp-units/systems/si/constants.h
+++ b/src/systems/include/mp-units/systems/si/constants.h
@@ -35,28 +35,28 @@ namespace mp_units::si {
 namespace si2019 {
 
 // clang-format off
-inline constexpr struct hyperfine_structure_transition_frequency_of_cs final :
+constexpr struct hyperfine_structure_transition_frequency_of_cs final :
   named_unit<symbol_text{u8"Δν_Cs", "dv_Cs"}, mag<9'192'631'770> * hertz> {} hyperfine_structure_transition_frequency_of_cs;
-inline constexpr struct speed_of_light_in_vacuum final :
+constexpr struct speed_of_light_in_vacuum final :
   named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
-inline constexpr struct planck_constant final :
+constexpr struct planck_constant final :
   named_unit<"h", mag_ratio<662'607'015, 100'000'000> * mag_power<10, -34> * joule * second> {} planck_constant;
-inline constexpr struct elementary_charge final :
+constexpr struct elementary_charge final :
   named_unit<"e", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * coulomb> {} elementary_charge;
-inline constexpr struct boltzmann_constant final :
+constexpr struct boltzmann_constant final :
   named_unit<"k", mag_ratio<1'380'649, 1'000'000> * mag_power<10, -23> * joule / kelvin> {} boltzmann_constant;
-inline constexpr struct avogadro_constant final :
+constexpr struct avogadro_constant final :
   named_unit<"N_A", mag_ratio<602'214'076, 100'000'000> * mag_power<10, 23> / mole> {} avogadro_constant;
-inline constexpr struct luminous_efficacy final :
+constexpr struct luminous_efficacy final :
   named_unit<"K_cd", mag<683> * lumen / watt> {} luminous_efficacy;
 // clang-format on
 
 }  // namespace si2019
 
 // clang-format off
-inline constexpr struct standard_gravity final :
+constexpr struct standard_gravity final :
   named_unit<symbol_text{u8"g₀", "g_0"}, mag_ratio<980'665, 100'000> * metre / square(second)> {} standard_gravity;
-inline constexpr struct magnetic_constant final :
+constexpr struct magnetic_constant final :
   named_unit<symbol_text{u8"μ₀", "u_0"}, mag<4> * mag_pi * mag_power<10, -7> * henry / metre> {} magnetic_constant;
 // clang-format on
 
diff --git a/src/systems/include/mp-units/systems/si/prefixes.h b/src/systems/include/mp-units/systems/si/prefixes.h
index 3ee39e13..a0efa949 100644
--- a/src/systems/include/mp-units/systems/si/prefixes.h
+++ b/src/systems/include/mp-units/systems/si/prefixes.h
@@ -58,30 +58,30 @@ template<PrefixableUnit U> struct quetta_ final : prefixed_unit<"Q", mag_power<1
 
 MP_UNITS_EXPORT_BEGIN
 
-template<PrefixableUnit auto U> inline constexpr quecto_<MP_UNITS_REMOVE_CONST(decltype(U))> quecto;
-template<PrefixableUnit auto U> inline constexpr ronto_<MP_UNITS_REMOVE_CONST(decltype(U))> ronto;
-template<PrefixableUnit auto U> inline constexpr yocto_<MP_UNITS_REMOVE_CONST(decltype(U))> yocto;
-template<PrefixableUnit auto U> inline constexpr zepto_<MP_UNITS_REMOVE_CONST(decltype(U))> zepto;
-template<PrefixableUnit auto U> inline constexpr atto_<MP_UNITS_REMOVE_CONST(decltype(U))> atto;
-template<PrefixableUnit auto U> inline constexpr femto_<MP_UNITS_REMOVE_CONST(decltype(U))> femto;
-template<PrefixableUnit auto U> inline constexpr pico_<MP_UNITS_REMOVE_CONST(decltype(U))> pico;
-template<PrefixableUnit auto U> inline constexpr nano_<MP_UNITS_REMOVE_CONST(decltype(U))> nano;
-template<PrefixableUnit auto U> inline constexpr micro_<MP_UNITS_REMOVE_CONST(decltype(U))> micro;
-template<PrefixableUnit auto U> inline constexpr milli_<MP_UNITS_REMOVE_CONST(decltype(U))> milli;
-template<PrefixableUnit auto U> inline constexpr centi_<MP_UNITS_REMOVE_CONST(decltype(U))> centi;
-template<PrefixableUnit auto U> inline constexpr deci_<MP_UNITS_REMOVE_CONST(decltype(U))> deci;
-template<PrefixableUnit auto U> inline constexpr deca_<MP_UNITS_REMOVE_CONST(decltype(U))> deca;
-template<PrefixableUnit auto U> inline constexpr hecto_<MP_UNITS_REMOVE_CONST(decltype(U))> hecto;
-template<PrefixableUnit auto U> inline constexpr kilo_<MP_UNITS_REMOVE_CONST(decltype(U))> kilo;
-template<PrefixableUnit auto U> inline constexpr mega_<MP_UNITS_REMOVE_CONST(decltype(U))> mega;
-template<PrefixableUnit auto U> inline constexpr giga_<MP_UNITS_REMOVE_CONST(decltype(U))> giga;
-template<PrefixableUnit auto U> inline constexpr tera_<MP_UNITS_REMOVE_CONST(decltype(U))> tera;
-template<PrefixableUnit auto U> inline constexpr peta_<MP_UNITS_REMOVE_CONST(decltype(U))> peta;
-template<PrefixableUnit auto U> inline constexpr exa_<MP_UNITS_REMOVE_CONST(decltype(U))> exa;
-template<PrefixableUnit auto U> inline constexpr zetta_<MP_UNITS_REMOVE_CONST(decltype(U))> zetta;
-template<PrefixableUnit auto U> inline constexpr yotta_<MP_UNITS_REMOVE_CONST(decltype(U))> yotta;
-template<PrefixableUnit auto U> inline constexpr ronna_<MP_UNITS_REMOVE_CONST(decltype(U))> ronna;
-template<PrefixableUnit auto U> inline constexpr quetta_<MP_UNITS_REMOVE_CONST(decltype(U))> quetta;
+template<PrefixableUnit auto U> constexpr quecto_<MP_UNITS_REMOVE_CONST(decltype(U))> quecto;
+template<PrefixableUnit auto U> constexpr ronto_<MP_UNITS_REMOVE_CONST(decltype(U))> ronto;
+template<PrefixableUnit auto U> constexpr yocto_<MP_UNITS_REMOVE_CONST(decltype(U))> yocto;
+template<PrefixableUnit auto U> constexpr zepto_<MP_UNITS_REMOVE_CONST(decltype(U))> zepto;
+template<PrefixableUnit auto U> constexpr atto_<MP_UNITS_REMOVE_CONST(decltype(U))> atto;
+template<PrefixableUnit auto U> constexpr femto_<MP_UNITS_REMOVE_CONST(decltype(U))> femto;
+template<PrefixableUnit auto U> constexpr pico_<MP_UNITS_REMOVE_CONST(decltype(U))> pico;
+template<PrefixableUnit auto U> constexpr nano_<MP_UNITS_REMOVE_CONST(decltype(U))> nano;
+template<PrefixableUnit auto U> constexpr micro_<MP_UNITS_REMOVE_CONST(decltype(U))> micro;
+template<PrefixableUnit auto U> constexpr milli_<MP_UNITS_REMOVE_CONST(decltype(U))> milli;
+template<PrefixableUnit auto U> constexpr centi_<MP_UNITS_REMOVE_CONST(decltype(U))> centi;
+template<PrefixableUnit auto U> constexpr deci_<MP_UNITS_REMOVE_CONST(decltype(U))> deci;
+template<PrefixableUnit auto U> constexpr deca_<MP_UNITS_REMOVE_CONST(decltype(U))> deca;
+template<PrefixableUnit auto U> constexpr hecto_<MP_UNITS_REMOVE_CONST(decltype(U))> hecto;
+template<PrefixableUnit auto U> constexpr kilo_<MP_UNITS_REMOVE_CONST(decltype(U))> kilo;
+template<PrefixableUnit auto U> constexpr mega_<MP_UNITS_REMOVE_CONST(decltype(U))> mega;
+template<PrefixableUnit auto U> constexpr giga_<MP_UNITS_REMOVE_CONST(decltype(U))> giga;
+template<PrefixableUnit auto U> constexpr tera_<MP_UNITS_REMOVE_CONST(decltype(U))> tera;
+template<PrefixableUnit auto U> constexpr peta_<MP_UNITS_REMOVE_CONST(decltype(U))> peta;
+template<PrefixableUnit auto U> constexpr exa_<MP_UNITS_REMOVE_CONST(decltype(U))> exa;
+template<PrefixableUnit auto U> constexpr zetta_<MP_UNITS_REMOVE_CONST(decltype(U))> zetta;
+template<PrefixableUnit auto U> constexpr yotta_<MP_UNITS_REMOVE_CONST(decltype(U))> yotta;
+template<PrefixableUnit auto U> constexpr ronna_<MP_UNITS_REMOVE_CONST(decltype(U))> ronna;
+template<PrefixableUnit auto U> constexpr quetta_<MP_UNITS_REMOVE_CONST(decltype(U))> quetta;
 // clang-format on
 
 MP_UNITS_EXPORT_END
diff --git a/src/systems/include/mp-units/systems/si/unit_symbols.h b/src/systems/include/mp-units/systems/si/unit_symbols.h
index 466c956c..ce5e68d8 100644
--- a/src/systems/include/mp-units/systems/si/unit_symbols.h
+++ b/src/systems/include/mp-units/systems/si/unit_symbols.h
@@ -31,774 +31,774 @@ namespace mp_units {
 
 namespace si::unit_symbols {
 
-inline constexpr auto qm = quecto<metre>;
-inline constexpr auto rm = ronto<metre>;
-inline constexpr auto ym = yocto<metre>;
-inline constexpr auto zm = zepto<metre>;
-inline constexpr auto am = atto<metre>;
-inline constexpr auto fm = femto<metre>;
-inline constexpr auto pm = pico<metre>;
-inline constexpr auto nm = nano<metre>;
-inline constexpr auto um = micro<metre>;
-inline constexpr auto mm = milli<metre>;
-inline constexpr auto cm = centi<metre>;
-inline constexpr auto dm = deci<metre>;
-inline constexpr auto m = metre;
-inline constexpr auto dam = deca<metre>;
-inline constexpr auto hm = hecto<metre>;
-inline constexpr auto km = kilo<metre>;
-inline constexpr auto Mm = mega<metre>;
-inline constexpr auto Gm = giga<metre>;
-inline constexpr auto Tm = tera<metre>;
-inline constexpr auto Pm = peta<metre>;
-inline constexpr auto Em = exa<metre>;
-inline constexpr auto Zm = zetta<metre>;
-inline constexpr auto Ym = yotta<metre>;
-inline constexpr auto Rm = ronna<metre>;
-inline constexpr auto Qm = quetta<metre>;
+constexpr auto qm = quecto<metre>;
+constexpr auto rm = ronto<metre>;
+constexpr auto ym = yocto<metre>;
+constexpr auto zm = zepto<metre>;
+constexpr auto am = atto<metre>;
+constexpr auto fm = femto<metre>;
+constexpr auto pm = pico<metre>;
+constexpr auto nm = nano<metre>;
+constexpr auto um = micro<metre>;
+constexpr auto mm = milli<metre>;
+constexpr auto cm = centi<metre>;
+constexpr auto dm = deci<metre>;
+constexpr auto m = metre;
+constexpr auto dam = deca<metre>;
+constexpr auto hm = hecto<metre>;
+constexpr auto km = kilo<metre>;
+constexpr auto Mm = mega<metre>;
+constexpr auto Gm = giga<metre>;
+constexpr auto Tm = tera<metre>;
+constexpr auto Pm = peta<metre>;
+constexpr auto Em = exa<metre>;
+constexpr auto Zm = zetta<metre>;
+constexpr auto Ym = yotta<metre>;
+constexpr auto Rm = ronna<metre>;
+constexpr auto Qm = quetta<metre>;
 
-inline constexpr auto qs = quecto<second>;
-inline constexpr auto rs = ronto<second>;
-inline constexpr auto ys = yocto<second>;
-inline constexpr auto zs = zepto<second>;
-inline constexpr auto as = atto<second>;
-inline constexpr auto fs = femto<second>;
-inline constexpr auto ps = pico<second>;
-inline constexpr auto ns = nano<second>;
-inline constexpr auto us = micro<second>;
-inline constexpr auto ms = milli<second>;
-inline constexpr auto cs = centi<second>;
-inline constexpr auto ds = deci<second>;
-inline constexpr auto s = second;
+constexpr auto qs = quecto<second>;
+constexpr auto rs = ronto<second>;
+constexpr auto ys = yocto<second>;
+constexpr auto zs = zepto<second>;
+constexpr auto as = atto<second>;
+constexpr auto fs = femto<second>;
+constexpr auto ps = pico<second>;
+constexpr auto ns = nano<second>;
+constexpr auto us = micro<second>;
+constexpr auto ms = milli<second>;
+constexpr auto cs = centi<second>;
+constexpr auto ds = deci<second>;
+constexpr auto s = second;
 // TODO Should the below multiples of second be provided?
-inline constexpr auto das = deca<second>;
-inline constexpr auto hs = hecto<second>;
-inline constexpr auto ks = kilo<second>;
-inline constexpr auto Ms = mega<second>;
-inline constexpr auto Gs = giga<second>;
-inline constexpr auto Ts = tera<second>;
-inline constexpr auto Ps = peta<second>;
-inline constexpr auto Es = exa<second>;
-inline constexpr auto Zs = zetta<second>;
-inline constexpr auto Ys = yotta<second>;
-inline constexpr auto Rs = ronna<second>;
-inline constexpr auto Qs = quetta<second>;
+constexpr auto das = deca<second>;
+constexpr auto hs = hecto<second>;
+constexpr auto ks = kilo<second>;
+constexpr auto Ms = mega<second>;
+constexpr auto Gs = giga<second>;
+constexpr auto Ts = tera<second>;
+constexpr auto Ps = peta<second>;
+constexpr auto Es = exa<second>;
+constexpr auto Zs = zetta<second>;
+constexpr auto Ys = yotta<second>;
+constexpr auto Rs = ronna<second>;
+constexpr auto Qs = quetta<second>;
 
-inline constexpr auto qg = quecto<gram>;
-inline constexpr auto rg = ronto<gram>;
-inline constexpr auto yg = yocto<gram>;
-inline constexpr auto zg = zepto<gram>;
-inline constexpr auto ag = atto<gram>;
-inline constexpr auto fg = femto<gram>;
-inline constexpr auto pg = pico<gram>;
-inline constexpr auto ng = nano<gram>;
-inline constexpr auto ug = micro<gram>;
-inline constexpr auto mg = milli<gram>;
-inline constexpr auto cg = centi<gram>;
-inline constexpr auto dg = deci<gram>;
-inline constexpr auto g = gram;
-inline constexpr auto dag = deca<gram>;
-inline constexpr auto hg = hecto<gram>;
-inline constexpr auto kg = kilogram;
-inline constexpr auto Mg = mega<gram>;
-inline constexpr auto Gg = giga<gram>;
-inline constexpr auto Tg = tera<gram>;
-inline constexpr auto Pg = peta<gram>;
-inline constexpr auto Eg = exa<gram>;
-inline constexpr auto Zg = zetta<gram>;
-inline constexpr auto Yg = yotta<gram>;
-inline constexpr auto Rg = ronna<gram>;
-inline constexpr auto Qg = quetta<gram>;
+constexpr auto qg = quecto<gram>;
+constexpr auto rg = ronto<gram>;
+constexpr auto yg = yocto<gram>;
+constexpr auto zg = zepto<gram>;
+constexpr auto ag = atto<gram>;
+constexpr auto fg = femto<gram>;
+constexpr auto pg = pico<gram>;
+constexpr auto ng = nano<gram>;
+constexpr auto ug = micro<gram>;
+constexpr auto mg = milli<gram>;
+constexpr auto cg = centi<gram>;
+constexpr auto dg = deci<gram>;
+constexpr auto g = gram;
+constexpr auto dag = deca<gram>;
+constexpr auto hg = hecto<gram>;
+constexpr auto kg = kilogram;
+constexpr auto Mg = mega<gram>;
+constexpr auto Gg = giga<gram>;
+constexpr auto Tg = tera<gram>;
+constexpr auto Pg = peta<gram>;
+constexpr auto Eg = exa<gram>;
+constexpr auto Zg = zetta<gram>;
+constexpr auto Yg = yotta<gram>;
+constexpr auto Rg = ronna<gram>;
+constexpr auto Qg = quetta<gram>;
 
-inline constexpr auto qA = quecto<ampere>;
-inline constexpr auto rA = ronto<ampere>;
-inline constexpr auto yA = yocto<ampere>;
-inline constexpr auto zA = zepto<ampere>;
-inline constexpr auto aA = atto<ampere>;
-inline constexpr auto fA = femto<ampere>;
-inline constexpr auto pA = pico<ampere>;
-inline constexpr auto nA = nano<ampere>;
-inline constexpr auto uA = micro<ampere>;
-inline constexpr auto mA = milli<ampere>;
-inline constexpr auto cA = centi<ampere>;
-inline constexpr auto dA = deci<ampere>;
-inline constexpr auto A = ampere;
-inline constexpr auto daA = deca<ampere>;
-inline constexpr auto hA = hecto<ampere>;
-inline constexpr auto kA = kilo<ampere>;
-inline constexpr auto MA = mega<ampere>;
-inline constexpr auto GA = giga<ampere>;
-inline constexpr auto TA = tera<ampere>;
-inline constexpr auto PA = peta<ampere>;
-inline constexpr auto EA = exa<ampere>;
-inline constexpr auto ZA = zetta<ampere>;
-inline constexpr auto YA = yotta<ampere>;
-inline constexpr auto RA = ronna<ampere>;
-inline constexpr auto QA = quetta<ampere>;
+constexpr auto qA = quecto<ampere>;
+constexpr auto rA = ronto<ampere>;
+constexpr auto yA = yocto<ampere>;
+constexpr auto zA = zepto<ampere>;
+constexpr auto aA = atto<ampere>;
+constexpr auto fA = femto<ampere>;
+constexpr auto pA = pico<ampere>;
+constexpr auto nA = nano<ampere>;
+constexpr auto uA = micro<ampere>;
+constexpr auto mA = milli<ampere>;
+constexpr auto cA = centi<ampere>;
+constexpr auto dA = deci<ampere>;
+constexpr auto A = ampere;
+constexpr auto daA = deca<ampere>;
+constexpr auto hA = hecto<ampere>;
+constexpr auto kA = kilo<ampere>;
+constexpr auto MA = mega<ampere>;
+constexpr auto GA = giga<ampere>;
+constexpr auto TA = tera<ampere>;
+constexpr auto PA = peta<ampere>;
+constexpr auto EA = exa<ampere>;
+constexpr auto ZA = zetta<ampere>;
+constexpr auto YA = yotta<ampere>;
+constexpr auto RA = ronna<ampere>;
+constexpr auto QA = quetta<ampere>;
 
-inline constexpr auto qK = quecto<kelvin>;
-inline constexpr auto rK = ronto<kelvin>;
-inline constexpr auto yK = yocto<kelvin>;
-inline constexpr auto zK = zepto<kelvin>;
-inline constexpr auto aK = atto<kelvin>;
-inline constexpr auto fK = femto<kelvin>;
-inline constexpr auto pK = pico<kelvin>;
-inline constexpr auto nK = nano<kelvin>;
-inline constexpr auto uK = micro<kelvin>;
-inline constexpr auto mK = milli<kelvin>;
-inline constexpr auto cK = centi<kelvin>;
-inline constexpr auto dK = deci<kelvin>;
-inline constexpr auto K = kelvin;
-inline constexpr auto daK = deca<kelvin>;
-inline constexpr auto hK = hecto<kelvin>;
-inline constexpr auto kK = kilo<kelvin>;
-inline constexpr auto MK = mega<kelvin>;
-inline constexpr auto GK = giga<kelvin>;
-inline constexpr auto TK = tera<kelvin>;
-inline constexpr auto PK = peta<kelvin>;
-inline constexpr auto EK = exa<kelvin>;
-inline constexpr auto ZK = zetta<kelvin>;
-inline constexpr auto YK = yotta<kelvin>;
-inline constexpr auto RK = ronna<kelvin>;
-inline constexpr auto QK = quetta<kelvin>;
+constexpr auto qK = quecto<kelvin>;
+constexpr auto rK = ronto<kelvin>;
+constexpr auto yK = yocto<kelvin>;
+constexpr auto zK = zepto<kelvin>;
+constexpr auto aK = atto<kelvin>;
+constexpr auto fK = femto<kelvin>;
+constexpr auto pK = pico<kelvin>;
+constexpr auto nK = nano<kelvin>;
+constexpr auto uK = micro<kelvin>;
+constexpr auto mK = milli<kelvin>;
+constexpr auto cK = centi<kelvin>;
+constexpr auto dK = deci<kelvin>;
+constexpr auto K = kelvin;
+constexpr auto daK = deca<kelvin>;
+constexpr auto hK = hecto<kelvin>;
+constexpr auto kK = kilo<kelvin>;
+constexpr auto MK = mega<kelvin>;
+constexpr auto GK = giga<kelvin>;
+constexpr auto TK = tera<kelvin>;
+constexpr auto PK = peta<kelvin>;
+constexpr auto EK = exa<kelvin>;
+constexpr auto ZK = zetta<kelvin>;
+constexpr auto YK = yotta<kelvin>;
+constexpr auto RK = ronna<kelvin>;
+constexpr auto QK = quetta<kelvin>;
 
-inline constexpr auto qmol = quecto<mole>;
-inline constexpr auto rmol = ronto<mole>;
-inline constexpr auto ymol = yocto<mole>;
-inline constexpr auto zmol = zepto<mole>;
-inline constexpr auto amol = atto<mole>;
-inline constexpr auto fmol = femto<mole>;
-inline constexpr auto pmol = pico<mole>;
-inline constexpr auto nmol = nano<mole>;
-inline constexpr auto umol = micro<mole>;
-inline constexpr auto mmol = milli<mole>;
-inline constexpr auto cmol = centi<mole>;
-inline constexpr auto dmol = deci<mole>;
-inline constexpr auto mol = mole;
-inline constexpr auto damol = deca<mole>;
-inline constexpr auto hmol = hecto<mole>;
-inline constexpr auto kmol = kilo<mole>;
-inline constexpr auto Mmol = mega<mole>;
-inline constexpr auto Gmol = giga<mole>;
-inline constexpr auto Tmol = tera<mole>;
-inline constexpr auto Pmol = peta<mole>;
-inline constexpr auto Emol = exa<mole>;
-inline constexpr auto Zmol = zetta<mole>;
-inline constexpr auto Ymol = yotta<mole>;
-inline constexpr auto Rmol = ronna<mole>;
-inline constexpr auto Qmol = quetta<mole>;
+constexpr auto qmol = quecto<mole>;
+constexpr auto rmol = ronto<mole>;
+constexpr auto ymol = yocto<mole>;
+constexpr auto zmol = zepto<mole>;
+constexpr auto amol = atto<mole>;
+constexpr auto fmol = femto<mole>;
+constexpr auto pmol = pico<mole>;
+constexpr auto nmol = nano<mole>;
+constexpr auto umol = micro<mole>;
+constexpr auto mmol = milli<mole>;
+constexpr auto cmol = centi<mole>;
+constexpr auto dmol = deci<mole>;
+constexpr auto mol = mole;
+constexpr auto damol = deca<mole>;
+constexpr auto hmol = hecto<mole>;
+constexpr auto kmol = kilo<mole>;
+constexpr auto Mmol = mega<mole>;
+constexpr auto Gmol = giga<mole>;
+constexpr auto Tmol = tera<mole>;
+constexpr auto Pmol = peta<mole>;
+constexpr auto Emol = exa<mole>;
+constexpr auto Zmol = zetta<mole>;
+constexpr auto Ymol = yotta<mole>;
+constexpr auto Rmol = ronna<mole>;
+constexpr auto Qmol = quetta<mole>;
 
-inline constexpr auto qcd = quecto<candela>;
-inline constexpr auto rcd = ronto<candela>;
-inline constexpr auto ycd = yocto<candela>;
-inline constexpr auto zcd = zepto<candela>;
-inline constexpr auto acd = atto<candela>;
-inline constexpr auto fcd = femto<candela>;
-inline constexpr auto pcd = pico<candela>;
-inline constexpr auto ncd = nano<candela>;
-inline constexpr auto ucd = micro<candela>;
-inline constexpr auto mcd = milli<candela>;
-inline constexpr auto ccd = centi<candela>;
-inline constexpr auto dcd = deci<candela>;
-inline constexpr auto cd = candela;
-inline constexpr auto dacd = deca<candela>;
-inline constexpr auto hcd = hecto<candela>;
-inline constexpr auto kcd = kilo<candela>;
-inline constexpr auto Mcd = mega<candela>;
-inline constexpr auto Gcd = giga<candela>;
-inline constexpr auto Tcd = tera<candela>;
-inline constexpr auto Pcd = peta<candela>;
-inline constexpr auto Ecd = exa<candela>;
-inline constexpr auto Zcd = zetta<candela>;
-inline constexpr auto Ycd = yotta<candela>;
-inline constexpr auto Rcd = ronna<candela>;
-inline constexpr auto Qcd = quetta<candela>;
+constexpr auto qcd = quecto<candela>;
+constexpr auto rcd = ronto<candela>;
+constexpr auto ycd = yocto<candela>;
+constexpr auto zcd = zepto<candela>;
+constexpr auto acd = atto<candela>;
+constexpr auto fcd = femto<candela>;
+constexpr auto pcd = pico<candela>;
+constexpr auto ncd = nano<candela>;
+constexpr auto ucd = micro<candela>;
+constexpr auto mcd = milli<candela>;
+constexpr auto ccd = centi<candela>;
+constexpr auto dcd = deci<candela>;
+constexpr auto cd = candela;
+constexpr auto dacd = deca<candela>;
+constexpr auto hcd = hecto<candela>;
+constexpr auto kcd = kilo<candela>;
+constexpr auto Mcd = mega<candela>;
+constexpr auto Gcd = giga<candela>;
+constexpr auto Tcd = tera<candela>;
+constexpr auto Pcd = peta<candela>;
+constexpr auto Ecd = exa<candela>;
+constexpr auto Zcd = zetta<candela>;
+constexpr auto Ycd = yotta<candela>;
+constexpr auto Rcd = ronna<candela>;
+constexpr auto Qcd = quetta<candela>;
 
-inline constexpr auto qrad = quecto<radian>;
-inline constexpr auto rrad = ronto<radian>;
-inline constexpr auto yrad = yocto<radian>;
-inline constexpr auto zrad = zepto<radian>;
-inline constexpr auto arad = atto<radian>;
-inline constexpr auto frad = femto<radian>;
-inline constexpr auto prad = pico<radian>;
-inline constexpr auto nrad = nano<radian>;
-inline constexpr auto urad = micro<radian>;
-inline constexpr auto mrad = milli<radian>;
-inline constexpr auto crad = centi<radian>;
-inline constexpr auto drad = deci<radian>;
-inline constexpr auto rad = radian;
-inline constexpr auto darad = deca<radian>;
-inline constexpr auto hrad = hecto<radian>;
-inline constexpr auto krad = kilo<radian>;
-inline constexpr auto Mrad = mega<radian>;
-inline constexpr auto Grad = giga<radian>;
-inline constexpr auto Trad = tera<radian>;
-inline constexpr auto Prad = peta<radian>;
-inline constexpr auto Erad = exa<radian>;
-inline constexpr auto Zrad = zetta<radian>;
-inline constexpr auto Yrad = yotta<radian>;
-inline constexpr auto Rrad = ronna<radian>;
-inline constexpr auto Qrad = quetta<radian>;
+constexpr auto qrad = quecto<radian>;
+constexpr auto rrad = ronto<radian>;
+constexpr auto yrad = yocto<radian>;
+constexpr auto zrad = zepto<radian>;
+constexpr auto arad = atto<radian>;
+constexpr auto frad = femto<radian>;
+constexpr auto prad = pico<radian>;
+constexpr auto nrad = nano<radian>;
+constexpr auto urad = micro<radian>;
+constexpr auto mrad = milli<radian>;
+constexpr auto crad = centi<radian>;
+constexpr auto drad = deci<radian>;
+constexpr auto rad = radian;
+constexpr auto darad = deca<radian>;
+constexpr auto hrad = hecto<radian>;
+constexpr auto krad = kilo<radian>;
+constexpr auto Mrad = mega<radian>;
+constexpr auto Grad = giga<radian>;
+constexpr auto Trad = tera<radian>;
+constexpr auto Prad = peta<radian>;
+constexpr auto Erad = exa<radian>;
+constexpr auto Zrad = zetta<radian>;
+constexpr auto Yrad = yotta<radian>;
+constexpr auto Rrad = ronna<radian>;
+constexpr auto Qrad = quetta<radian>;
 
-inline constexpr auto qsr = quecto<steradian>;
-inline constexpr auto rsr = ronto<steradian>;
-inline constexpr auto ysr = yocto<steradian>;
-inline constexpr auto zsr = zepto<steradian>;
-inline constexpr auto asr = atto<steradian>;
-inline constexpr auto fsr = femto<steradian>;
-inline constexpr auto psr = pico<steradian>;
-inline constexpr auto nsr = nano<steradian>;
-inline constexpr auto usr = micro<steradian>;
-inline constexpr auto msr = milli<steradian>;
-inline constexpr auto csr = centi<steradian>;
-inline constexpr auto dsr = deci<steradian>;
-inline constexpr auto sr = steradian;
-inline constexpr auto dasr = deca<steradian>;
-inline constexpr auto hsr = hecto<steradian>;
-inline constexpr auto ksr = kilo<steradian>;
-inline constexpr auto Msr = mega<steradian>;
-inline constexpr auto Gsr = giga<steradian>;
-inline constexpr auto Tsr = tera<steradian>;
-inline constexpr auto Psr = peta<steradian>;
-inline constexpr auto Esr = exa<steradian>;
-inline constexpr auto Zsr = zetta<steradian>;
-inline constexpr auto Ysr = yotta<steradian>;
-inline constexpr auto Rsr = ronna<steradian>;
-inline constexpr auto Qsr = quetta<steradian>;
+constexpr auto qsr = quecto<steradian>;
+constexpr auto rsr = ronto<steradian>;
+constexpr auto ysr = yocto<steradian>;
+constexpr auto zsr = zepto<steradian>;
+constexpr auto asr = atto<steradian>;
+constexpr auto fsr = femto<steradian>;
+constexpr auto psr = pico<steradian>;
+constexpr auto nsr = nano<steradian>;
+constexpr auto usr = micro<steradian>;
+constexpr auto msr = milli<steradian>;
+constexpr auto csr = centi<steradian>;
+constexpr auto dsr = deci<steradian>;
+constexpr auto sr = steradian;
+constexpr auto dasr = deca<steradian>;
+constexpr auto hsr = hecto<steradian>;
+constexpr auto ksr = kilo<steradian>;
+constexpr auto Msr = mega<steradian>;
+constexpr auto Gsr = giga<steradian>;
+constexpr auto Tsr = tera<steradian>;
+constexpr auto Psr = peta<steradian>;
+constexpr auto Esr = exa<steradian>;
+constexpr auto Zsr = zetta<steradian>;
+constexpr auto Ysr = yotta<steradian>;
+constexpr auto Rsr = ronna<steradian>;
+constexpr auto Qsr = quetta<steradian>;
 
-inline constexpr auto qHz = quecto<hertz>;
-inline constexpr auto rHz = ronto<hertz>;
-inline constexpr auto yHz = yocto<hertz>;
-inline constexpr auto zHz = zepto<hertz>;
-inline constexpr auto aHz = atto<hertz>;
-inline constexpr auto fHz = femto<hertz>;
-inline constexpr auto pHz = pico<hertz>;
-inline constexpr auto nHz = nano<hertz>;
-inline constexpr auto uHz = micro<hertz>;
-inline constexpr auto mHz = milli<hertz>;
-inline constexpr auto cHz = centi<hertz>;
-inline constexpr auto dHz = deci<hertz>;
-inline constexpr auto Hz = hertz;
-inline constexpr auto daHz = deca<hertz>;
-inline constexpr auto hHz = hecto<hertz>;
-inline constexpr auto kHz = kilo<hertz>;
-inline constexpr auto MHz = mega<hertz>;
-inline constexpr auto GHz = giga<hertz>;
-inline constexpr auto THz = tera<hertz>;
-inline constexpr auto PHz = peta<hertz>;
-inline constexpr auto EHz = exa<hertz>;
-inline constexpr auto ZHz = zetta<hertz>;
-inline constexpr auto YHz = yotta<hertz>;
-inline constexpr auto RHz = ronna<hertz>;
-inline constexpr auto QHz = quetta<hertz>;
+constexpr auto qHz = quecto<hertz>;
+constexpr auto rHz = ronto<hertz>;
+constexpr auto yHz = yocto<hertz>;
+constexpr auto zHz = zepto<hertz>;
+constexpr auto aHz = atto<hertz>;
+constexpr auto fHz = femto<hertz>;
+constexpr auto pHz = pico<hertz>;
+constexpr auto nHz = nano<hertz>;
+constexpr auto uHz = micro<hertz>;
+constexpr auto mHz = milli<hertz>;
+constexpr auto cHz = centi<hertz>;
+constexpr auto dHz = deci<hertz>;
+constexpr auto Hz = hertz;
+constexpr auto daHz = deca<hertz>;
+constexpr auto hHz = hecto<hertz>;
+constexpr auto kHz = kilo<hertz>;
+constexpr auto MHz = mega<hertz>;
+constexpr auto GHz = giga<hertz>;
+constexpr auto THz = tera<hertz>;
+constexpr auto PHz = peta<hertz>;
+constexpr auto EHz = exa<hertz>;
+constexpr auto ZHz = zetta<hertz>;
+constexpr auto YHz = yotta<hertz>;
+constexpr auto RHz = ronna<hertz>;
+constexpr auto QHz = quetta<hertz>;
 
-inline constexpr auto qN = quecto<newton>;
-inline constexpr auto rN = ronto<newton>;
-inline constexpr auto yN = yocto<newton>;
-inline constexpr auto zN = zepto<newton>;
-inline constexpr auto aN = atto<newton>;
-inline constexpr auto fN = femto<newton>;
-inline constexpr auto pN = pico<newton>;
-inline constexpr auto nN = nano<newton>;
-inline constexpr auto uN = micro<newton>;
-inline constexpr auto mN = milli<newton>;
-inline constexpr auto cN = centi<newton>;
-inline constexpr auto dN = deci<newton>;
-inline constexpr auto N = newton;
-inline constexpr auto daN = deca<newton>;
-inline constexpr auto hN = hecto<newton>;
-inline constexpr auto kN = kilo<newton>;
-inline constexpr auto MN = mega<newton>;
-inline constexpr auto GN = giga<newton>;
-inline constexpr auto TN = tera<newton>;
-inline constexpr auto PN = peta<newton>;
-inline constexpr auto EN = exa<newton>;
-inline constexpr auto ZN = zetta<newton>;
-inline constexpr auto YN = yotta<newton>;
-inline constexpr auto RN = ronna<newton>;
-inline constexpr auto QN = quetta<newton>;
+constexpr auto qN = quecto<newton>;
+constexpr auto rN = ronto<newton>;
+constexpr auto yN = yocto<newton>;
+constexpr auto zN = zepto<newton>;
+constexpr auto aN = atto<newton>;
+constexpr auto fN = femto<newton>;
+constexpr auto pN = pico<newton>;
+constexpr auto nN = nano<newton>;
+constexpr auto uN = micro<newton>;
+constexpr auto mN = milli<newton>;
+constexpr auto cN = centi<newton>;
+constexpr auto dN = deci<newton>;
+constexpr auto N = newton;
+constexpr auto daN = deca<newton>;
+constexpr auto hN = hecto<newton>;
+constexpr auto kN = kilo<newton>;
+constexpr auto MN = mega<newton>;
+constexpr auto GN = giga<newton>;
+constexpr auto TN = tera<newton>;
+constexpr auto PN = peta<newton>;
+constexpr auto EN = exa<newton>;
+constexpr auto ZN = zetta<newton>;
+constexpr auto YN = yotta<newton>;
+constexpr auto RN = ronna<newton>;
+constexpr auto QN = quetta<newton>;
 
 #ifdef pascal
 #pragma push_macro("pascal")
 #undef pascal
 #define MP_UNITS_REDEFINE_PASCAL
 #endif
-inline constexpr auto qPa = quecto<pascal>;
-inline constexpr auto rPa = ronto<pascal>;
-inline constexpr auto yPa = yocto<pascal>;
-inline constexpr auto zPa = zepto<pascal>;
-inline constexpr auto aPa = atto<pascal>;
-inline constexpr auto fPa = femto<pascal>;
-inline constexpr auto pPa = pico<pascal>;
-inline constexpr auto nPa = nano<pascal>;
-inline constexpr auto uPa = micro<pascal>;
-inline constexpr auto mPa = milli<pascal>;
-inline constexpr auto cPa = centi<pascal>;
-inline constexpr auto dPa = deci<pascal>;
-inline constexpr auto Pa = pascal;
-inline constexpr auto daPa = deca<pascal>;
-inline constexpr auto hPa = hecto<pascal>;
-inline constexpr auto kPa = kilo<pascal>;
-inline constexpr auto MPa = mega<pascal>;
-inline constexpr auto GPa = giga<pascal>;
-inline constexpr auto TPa = tera<pascal>;
-inline constexpr auto PPa = peta<pascal>;
-inline constexpr auto EPa = exa<pascal>;
-inline constexpr auto ZPa = zetta<pascal>;
-inline constexpr auto YPa = yotta<pascal>;
-inline constexpr auto RPa = ronna<pascal>;
-inline constexpr auto QPa = quetta<pascal>;
+constexpr auto qPa = quecto<pascal>;
+constexpr auto rPa = ronto<pascal>;
+constexpr auto yPa = yocto<pascal>;
+constexpr auto zPa = zepto<pascal>;
+constexpr auto aPa = atto<pascal>;
+constexpr auto fPa = femto<pascal>;
+constexpr auto pPa = pico<pascal>;
+constexpr auto nPa = nano<pascal>;
+constexpr auto uPa = micro<pascal>;
+constexpr auto mPa = milli<pascal>;
+constexpr auto cPa = centi<pascal>;
+constexpr auto dPa = deci<pascal>;
+constexpr auto Pa = pascal;
+constexpr auto daPa = deca<pascal>;
+constexpr auto hPa = hecto<pascal>;
+constexpr auto kPa = kilo<pascal>;
+constexpr auto MPa = mega<pascal>;
+constexpr auto GPa = giga<pascal>;
+constexpr auto TPa = tera<pascal>;
+constexpr auto PPa = peta<pascal>;
+constexpr auto EPa = exa<pascal>;
+constexpr auto ZPa = zetta<pascal>;
+constexpr auto YPa = yotta<pascal>;
+constexpr auto RPa = ronna<pascal>;
+constexpr auto QPa = quetta<pascal>;
 #ifdef MP_UNITS_REDEFINE_PASCAL
 #pragma pop_macro("pascal")
 #undef MP_UNITS_REDEFINE_PASCAL
 #endif
 
-inline constexpr auto qJ = quecto<joule>;
-inline constexpr auto rJ = ronto<joule>;
-inline constexpr auto yJ = yocto<joule>;
-inline constexpr auto zJ = zepto<joule>;
-inline constexpr auto aJ = atto<joule>;
-inline constexpr auto fJ = femto<joule>;
-inline constexpr auto pJ = pico<joule>;
-inline constexpr auto nJ = nano<joule>;
-inline constexpr auto uJ = micro<joule>;
-inline constexpr auto mJ = milli<joule>;
-inline constexpr auto cJ = centi<joule>;
-inline constexpr auto dJ = deci<joule>;
-inline constexpr auto J = joule;
-inline constexpr auto daJ = deca<joule>;
-inline constexpr auto hJ = hecto<joule>;
-inline constexpr auto kJ = kilo<joule>;
-inline constexpr auto MJ = mega<joule>;
-inline constexpr auto GJ = giga<joule>;
-inline constexpr auto TJ = tera<joule>;
-inline constexpr auto PJ = peta<joule>;
-inline constexpr auto EJ = exa<joule>;
-inline constexpr auto ZJ = zetta<joule>;
-inline constexpr auto YJ = yotta<joule>;
-inline constexpr auto RJ = ronna<joule>;
-inline constexpr auto QJ = quetta<joule>;
+constexpr auto qJ = quecto<joule>;
+constexpr auto rJ = ronto<joule>;
+constexpr auto yJ = yocto<joule>;
+constexpr auto zJ = zepto<joule>;
+constexpr auto aJ = atto<joule>;
+constexpr auto fJ = femto<joule>;
+constexpr auto pJ = pico<joule>;
+constexpr auto nJ = nano<joule>;
+constexpr auto uJ = micro<joule>;
+constexpr auto mJ = milli<joule>;
+constexpr auto cJ = centi<joule>;
+constexpr auto dJ = deci<joule>;
+constexpr auto J = joule;
+constexpr auto daJ = deca<joule>;
+constexpr auto hJ = hecto<joule>;
+constexpr auto kJ = kilo<joule>;
+constexpr auto MJ = mega<joule>;
+constexpr auto GJ = giga<joule>;
+constexpr auto TJ = tera<joule>;
+constexpr auto PJ = peta<joule>;
+constexpr auto EJ = exa<joule>;
+constexpr auto ZJ = zetta<joule>;
+constexpr auto YJ = yotta<joule>;
+constexpr auto RJ = ronna<joule>;
+constexpr auto QJ = quetta<joule>;
 
-inline constexpr auto qW = quecto<watt>;
-inline constexpr auto rW = ronto<watt>;
-inline constexpr auto yW = yocto<watt>;
-inline constexpr auto zW = zepto<watt>;
-inline constexpr auto aW = atto<watt>;
-inline constexpr auto fW = femto<watt>;
-inline constexpr auto pW = pico<watt>;
-inline constexpr auto nW = nano<watt>;
-inline constexpr auto uW = micro<watt>;
-inline constexpr auto mW = milli<watt>;
-inline constexpr auto cW = centi<watt>;
-inline constexpr auto dW = deci<watt>;
-inline constexpr auto W = watt;
-inline constexpr auto daW = deca<watt>;
-inline constexpr auto hW = hecto<watt>;
-inline constexpr auto kW = kilo<watt>;
-inline constexpr auto MW = mega<watt>;
-inline constexpr auto GW = giga<watt>;
-inline constexpr auto TW = tera<watt>;
-inline constexpr auto PW = peta<watt>;
-inline constexpr auto EW = exa<watt>;
-inline constexpr auto ZW = zetta<watt>;
-inline constexpr auto YW = yotta<watt>;
-inline constexpr auto RW = ronna<watt>;
-inline constexpr auto QW = quetta<watt>;
+constexpr auto qW = quecto<watt>;
+constexpr auto rW = ronto<watt>;
+constexpr auto yW = yocto<watt>;
+constexpr auto zW = zepto<watt>;
+constexpr auto aW = atto<watt>;
+constexpr auto fW = femto<watt>;
+constexpr auto pW = pico<watt>;
+constexpr auto nW = nano<watt>;
+constexpr auto uW = micro<watt>;
+constexpr auto mW = milli<watt>;
+constexpr auto cW = centi<watt>;
+constexpr auto dW = deci<watt>;
+constexpr auto W = watt;
+constexpr auto daW = deca<watt>;
+constexpr auto hW = hecto<watt>;
+constexpr auto kW = kilo<watt>;
+constexpr auto MW = mega<watt>;
+constexpr auto GW = giga<watt>;
+constexpr auto TW = tera<watt>;
+constexpr auto PW = peta<watt>;
+constexpr auto EW = exa<watt>;
+constexpr auto ZW = zetta<watt>;
+constexpr auto YW = yotta<watt>;
+constexpr auto RW = ronna<watt>;
+constexpr auto QW = quetta<watt>;
 
-inline constexpr auto qC = quecto<coulomb>;
-inline constexpr auto rC = ronto<coulomb>;
-inline constexpr auto yC = yocto<coulomb>;
-inline constexpr auto zC = zepto<coulomb>;
-inline constexpr auto aC = atto<coulomb>;
-inline constexpr auto fC = femto<coulomb>;
-inline constexpr auto pC = pico<coulomb>;
-inline constexpr auto nC = nano<coulomb>;
-inline constexpr auto uC = micro<coulomb>;
-inline constexpr auto mC = milli<coulomb>;
-inline constexpr auto cC = centi<coulomb>;
-inline constexpr auto dC = deci<coulomb>;
-inline constexpr auto C = coulomb;
-inline constexpr auto daC = deca<coulomb>;
-inline constexpr auto hC = hecto<coulomb>;
-inline constexpr auto kC = kilo<coulomb>;
-inline constexpr auto MC = mega<coulomb>;
-inline constexpr auto GC = giga<coulomb>;
-inline constexpr auto TC = tera<coulomb>;
-inline constexpr auto PC = peta<coulomb>;
-inline constexpr auto EC = exa<coulomb>;
-inline constexpr auto ZC = zetta<coulomb>;
-inline constexpr auto YC = yotta<coulomb>;
-inline constexpr auto RC = ronna<coulomb>;
-inline constexpr auto QC = quetta<coulomb>;
+constexpr auto qC = quecto<coulomb>;
+constexpr auto rC = ronto<coulomb>;
+constexpr auto yC = yocto<coulomb>;
+constexpr auto zC = zepto<coulomb>;
+constexpr auto aC = atto<coulomb>;
+constexpr auto fC = femto<coulomb>;
+constexpr auto pC = pico<coulomb>;
+constexpr auto nC = nano<coulomb>;
+constexpr auto uC = micro<coulomb>;
+constexpr auto mC = milli<coulomb>;
+constexpr auto cC = centi<coulomb>;
+constexpr auto dC = deci<coulomb>;
+constexpr auto C = coulomb;
+constexpr auto daC = deca<coulomb>;
+constexpr auto hC = hecto<coulomb>;
+constexpr auto kC = kilo<coulomb>;
+constexpr auto MC = mega<coulomb>;
+constexpr auto GC = giga<coulomb>;
+constexpr auto TC = tera<coulomb>;
+constexpr auto PC = peta<coulomb>;
+constexpr auto EC = exa<coulomb>;
+constexpr auto ZC = zetta<coulomb>;
+constexpr auto YC = yotta<coulomb>;
+constexpr auto RC = ronna<coulomb>;
+constexpr auto QC = quetta<coulomb>;
 
-inline constexpr auto qV = quecto<volt>;
-inline constexpr auto rV = ronto<volt>;
-inline constexpr auto yV = yocto<volt>;
-inline constexpr auto zV = zepto<volt>;
-inline constexpr auto aV = atto<volt>;
-inline constexpr auto fV = femto<volt>;
-inline constexpr auto pV = pico<volt>;
-inline constexpr auto nV = nano<volt>;
-inline constexpr auto uV = micro<volt>;
-inline constexpr auto mV = milli<volt>;
-inline constexpr auto cV = centi<volt>;
-inline constexpr auto dV = deci<volt>;
-inline constexpr auto V = volt;
-inline constexpr auto daV = deca<volt>;
-inline constexpr auto hV = hecto<volt>;
-inline constexpr auto kV = kilo<volt>;
-inline constexpr auto MV = mega<volt>;
-inline constexpr auto GV = giga<volt>;
-inline constexpr auto TV = tera<volt>;
-inline constexpr auto PV = peta<volt>;
-inline constexpr auto EV = exa<volt>;
-inline constexpr auto ZV = zetta<volt>;
-inline constexpr auto YV = yotta<volt>;
-inline constexpr auto RV = ronna<volt>;
-inline constexpr auto QV = quetta<volt>;
+constexpr auto qV = quecto<volt>;
+constexpr auto rV = ronto<volt>;
+constexpr auto yV = yocto<volt>;
+constexpr auto zV = zepto<volt>;
+constexpr auto aV = atto<volt>;
+constexpr auto fV = femto<volt>;
+constexpr auto pV = pico<volt>;
+constexpr auto nV = nano<volt>;
+constexpr auto uV = micro<volt>;
+constexpr auto mV = milli<volt>;
+constexpr auto cV = centi<volt>;
+constexpr auto dV = deci<volt>;
+constexpr auto V = volt;
+constexpr auto daV = deca<volt>;
+constexpr auto hV = hecto<volt>;
+constexpr auto kV = kilo<volt>;
+constexpr auto MV = mega<volt>;
+constexpr auto GV = giga<volt>;
+constexpr auto TV = tera<volt>;
+constexpr auto PV = peta<volt>;
+constexpr auto EV = exa<volt>;
+constexpr auto ZV = zetta<volt>;
+constexpr auto YV = yotta<volt>;
+constexpr auto RV = ronna<volt>;
+constexpr auto QV = quetta<volt>;
 
-inline constexpr auto qF = quecto<farad>;
-inline constexpr auto rF = ronto<farad>;
-inline constexpr auto yF = yocto<farad>;
-inline constexpr auto zF = zepto<farad>;
-inline constexpr auto aF = atto<farad>;
-inline constexpr auto fF = femto<farad>;
-inline constexpr auto pF = pico<farad>;
-inline constexpr auto nF = nano<farad>;
-inline constexpr auto uF = micro<farad>;
-inline constexpr auto mF = milli<farad>;
-inline constexpr auto cF = centi<farad>;
-inline constexpr auto dF = deci<farad>;
-inline constexpr auto F = farad;
-inline constexpr auto daF = deca<farad>;
-inline constexpr auto hF = hecto<farad>;
-inline constexpr auto kF = kilo<farad>;
-inline constexpr auto MF = mega<farad>;
-inline constexpr auto GF = giga<farad>;
-inline constexpr auto TF = tera<farad>;
-inline constexpr auto PF = peta<farad>;
-inline constexpr auto EF = exa<farad>;
-inline constexpr auto ZF = zetta<farad>;
-inline constexpr auto YF = yotta<farad>;
-inline constexpr auto RF = ronna<farad>;
-inline constexpr auto QF = quetta<farad>;
+constexpr auto qF = quecto<farad>;
+constexpr auto rF = ronto<farad>;
+constexpr auto yF = yocto<farad>;
+constexpr auto zF = zepto<farad>;
+constexpr auto aF = atto<farad>;
+constexpr auto fF = femto<farad>;
+constexpr auto pF = pico<farad>;
+constexpr auto nF = nano<farad>;
+constexpr auto uF = micro<farad>;
+constexpr auto mF = milli<farad>;
+constexpr auto cF = centi<farad>;
+constexpr auto dF = deci<farad>;
+constexpr auto F = farad;
+constexpr auto daF = deca<farad>;
+constexpr auto hF = hecto<farad>;
+constexpr auto kF = kilo<farad>;
+constexpr auto MF = mega<farad>;
+constexpr auto GF = giga<farad>;
+constexpr auto TF = tera<farad>;
+constexpr auto PF = peta<farad>;
+constexpr auto EF = exa<farad>;
+constexpr auto ZF = zetta<farad>;
+constexpr auto YF = yotta<farad>;
+constexpr auto RF = ronna<farad>;
+constexpr auto QF = quetta<farad>;
 
-inline constexpr auto qohm = quecto<si::ohm>;
-inline constexpr auto rohm = ronto<si::ohm>;
-inline constexpr auto yohm = yocto<si::ohm>;
-inline constexpr auto zohm = zepto<si::ohm>;
-inline constexpr auto aohm = atto<si::ohm>;
-inline constexpr auto fohm = femto<si::ohm>;
-inline constexpr auto pohm = pico<si::ohm>;
-inline constexpr auto nohm = nano<si::ohm>;
-inline constexpr auto uohm = micro<si::ohm>;
-inline constexpr auto mohm = milli<si::ohm>;
-inline constexpr auto cohm = centi<si::ohm>;
-inline constexpr auto dohm = deci<si::ohm>;
+constexpr auto qohm = quecto<si::ohm>;
+constexpr auto rohm = ronto<si::ohm>;
+constexpr auto yohm = yocto<si::ohm>;
+constexpr auto zohm = zepto<si::ohm>;
+constexpr auto aohm = atto<si::ohm>;
+constexpr auto fohm = femto<si::ohm>;
+constexpr auto pohm = pico<si::ohm>;
+constexpr auto nohm = nano<si::ohm>;
+constexpr auto uohm = micro<si::ohm>;
+constexpr auto mohm = milli<si::ohm>;
+constexpr auto cohm = centi<si::ohm>;
+constexpr auto dohm = deci<si::ohm>;
 using si::ohm;
-inline constexpr auto daohm = deca<si::ohm>;
-inline constexpr auto hohm = hecto<si::ohm>;
-inline constexpr auto kohm = kilo<si::ohm>;
-inline constexpr auto Mohm = mega<si::ohm>;
-inline constexpr auto Gohm = giga<si::ohm>;
-inline constexpr auto Tohm = tera<si::ohm>;
-inline constexpr auto Pohm = peta<si::ohm>;
-inline constexpr auto Eohm = exa<si::ohm>;
-inline constexpr auto Zohm = zetta<si::ohm>;
-inline constexpr auto Yohm = yotta<si::ohm>;
-inline constexpr auto Rohm = ronna<si::ohm>;
-inline constexpr auto Qohm = quetta<si::ohm>;
+constexpr auto daohm = deca<si::ohm>;
+constexpr auto hohm = hecto<si::ohm>;
+constexpr auto kohm = kilo<si::ohm>;
+constexpr auto Mohm = mega<si::ohm>;
+constexpr auto Gohm = giga<si::ohm>;
+constexpr auto Tohm = tera<si::ohm>;
+constexpr auto Pohm = peta<si::ohm>;
+constexpr auto Eohm = exa<si::ohm>;
+constexpr auto Zohm = zetta<si::ohm>;
+constexpr auto Yohm = yotta<si::ohm>;
+constexpr auto Rohm = ronna<si::ohm>;
+constexpr auto Qohm = quetta<si::ohm>;
 
-inline constexpr auto qS = quecto<siemens>;
-inline constexpr auto rS = ronto<siemens>;
-inline constexpr auto yS = yocto<siemens>;
-inline constexpr auto zS = zepto<siemens>;
-inline constexpr auto aS = atto<siemens>;
-inline constexpr auto fS = femto<siemens>;
-inline constexpr auto pS = pico<siemens>;
-inline constexpr auto nS = nano<siemens>;
-inline constexpr auto uS = micro<siemens>;
-inline constexpr auto mS = milli<siemens>;
-inline constexpr auto cS = centi<siemens>;
-inline constexpr auto dS = deci<siemens>;
-inline constexpr auto S = siemens;
-inline constexpr auto daS = deca<siemens>;
-inline constexpr auto hS = hecto<siemens>;
-inline constexpr auto kS = kilo<siemens>;
-inline constexpr auto MS = mega<siemens>;
-inline constexpr auto GS = giga<siemens>;
-inline constexpr auto TS = tera<siemens>;
-inline constexpr auto PS = peta<siemens>;
-inline constexpr auto ES = exa<siemens>;
-inline constexpr auto ZS = zetta<siemens>;
-inline constexpr auto YS = yotta<siemens>;
-inline constexpr auto RS = ronna<siemens>;
-inline constexpr auto QS = quetta<siemens>;
+constexpr auto qS = quecto<siemens>;
+constexpr auto rS = ronto<siemens>;
+constexpr auto yS = yocto<siemens>;
+constexpr auto zS = zepto<siemens>;
+constexpr auto aS = atto<siemens>;
+constexpr auto fS = femto<siemens>;
+constexpr auto pS = pico<siemens>;
+constexpr auto nS = nano<siemens>;
+constexpr auto uS = micro<siemens>;
+constexpr auto mS = milli<siemens>;
+constexpr auto cS = centi<siemens>;
+constexpr auto dS = deci<siemens>;
+constexpr auto S = siemens;
+constexpr auto daS = deca<siemens>;
+constexpr auto hS = hecto<siemens>;
+constexpr auto kS = kilo<siemens>;
+constexpr auto MS = mega<siemens>;
+constexpr auto GS = giga<siemens>;
+constexpr auto TS = tera<siemens>;
+constexpr auto PS = peta<siemens>;
+constexpr auto ES = exa<siemens>;
+constexpr auto ZS = zetta<siemens>;
+constexpr auto YS = yotta<siemens>;
+constexpr auto RS = ronna<siemens>;
+constexpr auto QS = quetta<siemens>;
 
-inline constexpr auto qWb = quecto<weber>;
-inline constexpr auto rWb = ronto<weber>;
-inline constexpr auto yWb = yocto<weber>;
-inline constexpr auto zWb = zepto<weber>;
-inline constexpr auto aWb = atto<weber>;
-inline constexpr auto fWb = femto<weber>;
-inline constexpr auto pWb = pico<weber>;
-inline constexpr auto nWb = nano<weber>;
-inline constexpr auto uWb = micro<weber>;
-inline constexpr auto mWb = milli<weber>;
-inline constexpr auto cWb = centi<weber>;
-inline constexpr auto dWb = deci<weber>;
-inline constexpr auto Wb = weber;
-inline constexpr auto daWb = deca<weber>;
-inline constexpr auto hWb = hecto<weber>;
-inline constexpr auto kWb = kilo<weber>;
-inline constexpr auto MWb = mega<weber>;
-inline constexpr auto GWb = giga<weber>;
-inline constexpr auto TWb = tera<weber>;
-inline constexpr auto PWb = peta<weber>;
-inline constexpr auto EWb = exa<weber>;
-inline constexpr auto ZWb = zetta<weber>;
-inline constexpr auto YWb = yotta<weber>;
-inline constexpr auto RWb = ronna<weber>;
-inline constexpr auto QWb = quetta<weber>;
+constexpr auto qWb = quecto<weber>;
+constexpr auto rWb = ronto<weber>;
+constexpr auto yWb = yocto<weber>;
+constexpr auto zWb = zepto<weber>;
+constexpr auto aWb = atto<weber>;
+constexpr auto fWb = femto<weber>;
+constexpr auto pWb = pico<weber>;
+constexpr auto nWb = nano<weber>;
+constexpr auto uWb = micro<weber>;
+constexpr auto mWb = milli<weber>;
+constexpr auto cWb = centi<weber>;
+constexpr auto dWb = deci<weber>;
+constexpr auto Wb = weber;
+constexpr auto daWb = deca<weber>;
+constexpr auto hWb = hecto<weber>;
+constexpr auto kWb = kilo<weber>;
+constexpr auto MWb = mega<weber>;
+constexpr auto GWb = giga<weber>;
+constexpr auto TWb = tera<weber>;
+constexpr auto PWb = peta<weber>;
+constexpr auto EWb = exa<weber>;
+constexpr auto ZWb = zetta<weber>;
+constexpr auto YWb = yotta<weber>;
+constexpr auto RWb = ronna<weber>;
+constexpr auto QWb = quetta<weber>;
 
-inline constexpr auto qT = quecto<tesla>;
-inline constexpr auto rT = ronto<tesla>;
-inline constexpr auto yT = yocto<tesla>;
-inline constexpr auto zT = zepto<tesla>;
-inline constexpr auto aT = atto<tesla>;
-inline constexpr auto fT = femto<tesla>;
-inline constexpr auto pT = pico<tesla>;
-inline constexpr auto nT = nano<tesla>;
-inline constexpr auto uT = micro<tesla>;
-inline constexpr auto mT = milli<tesla>;
-inline constexpr auto cT = centi<tesla>;
-inline constexpr auto dT = deci<tesla>;
-inline constexpr auto T = tesla;
-inline constexpr auto daT = deca<tesla>;
-inline constexpr auto hT = hecto<tesla>;
-inline constexpr auto kT = kilo<tesla>;
-inline constexpr auto MT = mega<tesla>;
-inline constexpr auto GT = giga<tesla>;
-inline constexpr auto TT = tera<tesla>;
-inline constexpr auto PT = peta<tesla>;
-inline constexpr auto ET = exa<tesla>;
-inline constexpr auto ZT = zetta<tesla>;
-inline constexpr auto YT = yotta<tesla>;
-inline constexpr auto RT = ronna<tesla>;
-inline constexpr auto QT = quetta<tesla>;
+constexpr auto qT = quecto<tesla>;
+constexpr auto rT = ronto<tesla>;
+constexpr auto yT = yocto<tesla>;
+constexpr auto zT = zepto<tesla>;
+constexpr auto aT = atto<tesla>;
+constexpr auto fT = femto<tesla>;
+constexpr auto pT = pico<tesla>;
+constexpr auto nT = nano<tesla>;
+constexpr auto uT = micro<tesla>;
+constexpr auto mT = milli<tesla>;
+constexpr auto cT = centi<tesla>;
+constexpr auto dT = deci<tesla>;
+constexpr auto T = tesla;
+constexpr auto daT = deca<tesla>;
+constexpr auto hT = hecto<tesla>;
+constexpr auto kT = kilo<tesla>;
+constexpr auto MT = mega<tesla>;
+constexpr auto GT = giga<tesla>;
+constexpr auto TT = tera<tesla>;
+constexpr auto PT = peta<tesla>;
+constexpr auto ET = exa<tesla>;
+constexpr auto ZT = zetta<tesla>;
+constexpr auto YT = yotta<tesla>;
+constexpr auto RT = ronna<tesla>;
+constexpr auto QT = quetta<tesla>;
 
-inline constexpr auto qH = quecto<henry>;
-inline constexpr auto rH = ronto<henry>;
-inline constexpr auto yH = yocto<henry>;
-inline constexpr auto zH = zepto<henry>;
-inline constexpr auto aH = atto<henry>;
-inline constexpr auto fH = femto<henry>;
-inline constexpr auto pH = pico<henry>;
-inline constexpr auto nH = nano<henry>;
-inline constexpr auto uH = micro<henry>;
-inline constexpr auto mH = milli<henry>;
-inline constexpr auto cH = centi<henry>;
-inline constexpr auto dH = deci<henry>;
-inline constexpr auto H = henry;
-inline constexpr auto daH = deca<henry>;
-inline constexpr auto hH = hecto<henry>;
-inline constexpr auto kH = kilo<henry>;
-inline constexpr auto MH = mega<henry>;
-inline constexpr auto GH = giga<henry>;
-inline constexpr auto TH = tera<henry>;
-inline constexpr auto PH = peta<henry>;
-inline constexpr auto EH = exa<henry>;
-inline constexpr auto ZH = zetta<henry>;
-inline constexpr auto YH = yotta<henry>;
-inline constexpr auto RH = ronna<henry>;
-inline constexpr auto QH = quetta<henry>;
+constexpr auto qH = quecto<henry>;
+constexpr auto rH = ronto<henry>;
+constexpr auto yH = yocto<henry>;
+constexpr auto zH = zepto<henry>;
+constexpr auto aH = atto<henry>;
+constexpr auto fH = femto<henry>;
+constexpr auto pH = pico<henry>;
+constexpr auto nH = nano<henry>;
+constexpr auto uH = micro<henry>;
+constexpr auto mH = milli<henry>;
+constexpr auto cH = centi<henry>;
+constexpr auto dH = deci<henry>;
+constexpr auto H = henry;
+constexpr auto daH = deca<henry>;
+constexpr auto hH = hecto<henry>;
+constexpr auto kH = kilo<henry>;
+constexpr auto MH = mega<henry>;
+constexpr auto GH = giga<henry>;
+constexpr auto TH = tera<henry>;
+constexpr auto PH = peta<henry>;
+constexpr auto EH = exa<henry>;
+constexpr auto ZH = zetta<henry>;
+constexpr auto YH = yotta<henry>;
+constexpr auto RH = ronna<henry>;
+constexpr auto QH = quetta<henry>;
 
-inline constexpr auto qlm = quecto<lumen>;
-inline constexpr auto rlm = ronto<lumen>;
-inline constexpr auto ylm = yocto<lumen>;
-inline constexpr auto zlm = zepto<lumen>;
-inline constexpr auto alm = atto<lumen>;
-inline constexpr auto flm = femto<lumen>;
-inline constexpr auto plm = pico<lumen>;
-inline constexpr auto nlm = nano<lumen>;
-inline constexpr auto ulm = micro<lumen>;
-inline constexpr auto mlm = milli<lumen>;
-inline constexpr auto clm = centi<lumen>;
-inline constexpr auto dlm = deci<lumen>;
-inline constexpr auto lm = lumen;
-inline constexpr auto dalm = deca<lumen>;
-inline constexpr auto hlm = hecto<lumen>;
-inline constexpr auto klm = kilo<lumen>;
-inline constexpr auto Mlm = mega<lumen>;
-inline constexpr auto Glm = giga<lumen>;
-inline constexpr auto Tlm = tera<lumen>;
-inline constexpr auto Plm = peta<lumen>;
-inline constexpr auto Elm = exa<lumen>;
-inline constexpr auto Zlm = zetta<lumen>;
-inline constexpr auto Ylm = yotta<lumen>;
-inline constexpr auto Rlm = ronna<lumen>;
-inline constexpr auto Qlm = quetta<lumen>;
+constexpr auto qlm = quecto<lumen>;
+constexpr auto rlm = ronto<lumen>;
+constexpr auto ylm = yocto<lumen>;
+constexpr auto zlm = zepto<lumen>;
+constexpr auto alm = atto<lumen>;
+constexpr auto flm = femto<lumen>;
+constexpr auto plm = pico<lumen>;
+constexpr auto nlm = nano<lumen>;
+constexpr auto ulm = micro<lumen>;
+constexpr auto mlm = milli<lumen>;
+constexpr auto clm = centi<lumen>;
+constexpr auto dlm = deci<lumen>;
+constexpr auto lm = lumen;
+constexpr auto dalm = deca<lumen>;
+constexpr auto hlm = hecto<lumen>;
+constexpr auto klm = kilo<lumen>;
+constexpr auto Mlm = mega<lumen>;
+constexpr auto Glm = giga<lumen>;
+constexpr auto Tlm = tera<lumen>;
+constexpr auto Plm = peta<lumen>;
+constexpr auto Elm = exa<lumen>;
+constexpr auto Zlm = zetta<lumen>;
+constexpr auto Ylm = yotta<lumen>;
+constexpr auto Rlm = ronna<lumen>;
+constexpr auto Qlm = quetta<lumen>;
 
-inline constexpr auto qlx = quecto<lux>;
-inline constexpr auto rlx = ronto<lux>;
-inline constexpr auto ylx = yocto<lux>;
-inline constexpr auto zlx = zepto<lux>;
-inline constexpr auto alx = atto<lux>;
-inline constexpr auto flx = femto<lux>;
-inline constexpr auto plx = pico<lux>;
-inline constexpr auto nlx = nano<lux>;
-inline constexpr auto ulx = micro<lux>;
-inline constexpr auto mlx = milli<lux>;
-inline constexpr auto clx = centi<lux>;
-inline constexpr auto dlx = deci<lux>;
-inline constexpr auto lx = lux;
-inline constexpr auto dalx = deca<lux>;
-inline constexpr auto hlx = hecto<lux>;
-inline constexpr auto klx = kilo<lux>;
-inline constexpr auto Mlx = mega<lux>;
-inline constexpr auto Glx = giga<lux>;
-inline constexpr auto Tlx = tera<lux>;
-inline constexpr auto Plx = peta<lux>;
-inline constexpr auto Elx = exa<lux>;
-inline constexpr auto Zlx = zetta<lux>;
-inline constexpr auto Ylx = yotta<lux>;
-inline constexpr auto Rlx = ronna<lux>;
-inline constexpr auto Qlx = quetta<lux>;
+constexpr auto qlx = quecto<lux>;
+constexpr auto rlx = ronto<lux>;
+constexpr auto ylx = yocto<lux>;
+constexpr auto zlx = zepto<lux>;
+constexpr auto alx = atto<lux>;
+constexpr auto flx = femto<lux>;
+constexpr auto plx = pico<lux>;
+constexpr auto nlx = nano<lux>;
+constexpr auto ulx = micro<lux>;
+constexpr auto mlx = milli<lux>;
+constexpr auto clx = centi<lux>;
+constexpr auto dlx = deci<lux>;
+constexpr auto lx = lux;
+constexpr auto dalx = deca<lux>;
+constexpr auto hlx = hecto<lux>;
+constexpr auto klx = kilo<lux>;
+constexpr auto Mlx = mega<lux>;
+constexpr auto Glx = giga<lux>;
+constexpr auto Tlx = tera<lux>;
+constexpr auto Plx = peta<lux>;
+constexpr auto Elx = exa<lux>;
+constexpr auto Zlx = zetta<lux>;
+constexpr auto Ylx = yotta<lux>;
+constexpr auto Rlx = ronna<lux>;
+constexpr auto Qlx = quetta<lux>;
 
-inline constexpr auto qBq = quecto<becquerel>;
-inline constexpr auto rBq = ronto<becquerel>;
-inline constexpr auto yBq = yocto<becquerel>;
-inline constexpr auto zBq = zepto<becquerel>;
-inline constexpr auto aBq = atto<becquerel>;
-inline constexpr auto fBq = femto<becquerel>;
-inline constexpr auto pBq = pico<becquerel>;
-inline constexpr auto nBq = nano<becquerel>;
-inline constexpr auto uBq = micro<becquerel>;
-inline constexpr auto mBq = milli<becquerel>;
-inline constexpr auto cBq = centi<becquerel>;
-inline constexpr auto dBq = deci<becquerel>;
-inline constexpr auto Bq = becquerel;
-inline constexpr auto daBq = deca<becquerel>;
-inline constexpr auto hBq = hecto<becquerel>;
-inline constexpr auto kBq = kilo<becquerel>;
-inline constexpr auto MBq = mega<becquerel>;
-inline constexpr auto GBq = giga<becquerel>;
-inline constexpr auto TBq = tera<becquerel>;
-inline constexpr auto PBq = peta<becquerel>;
-inline constexpr auto EBq = exa<becquerel>;
-inline constexpr auto ZBq = zetta<becquerel>;
-inline constexpr auto YBq = yotta<becquerel>;
-inline constexpr auto RBq = ronna<becquerel>;
-inline constexpr auto QBq = quetta<becquerel>;
+constexpr auto qBq = quecto<becquerel>;
+constexpr auto rBq = ronto<becquerel>;
+constexpr auto yBq = yocto<becquerel>;
+constexpr auto zBq = zepto<becquerel>;
+constexpr auto aBq = atto<becquerel>;
+constexpr auto fBq = femto<becquerel>;
+constexpr auto pBq = pico<becquerel>;
+constexpr auto nBq = nano<becquerel>;
+constexpr auto uBq = micro<becquerel>;
+constexpr auto mBq = milli<becquerel>;
+constexpr auto cBq = centi<becquerel>;
+constexpr auto dBq = deci<becquerel>;
+constexpr auto Bq = becquerel;
+constexpr auto daBq = deca<becquerel>;
+constexpr auto hBq = hecto<becquerel>;
+constexpr auto kBq = kilo<becquerel>;
+constexpr auto MBq = mega<becquerel>;
+constexpr auto GBq = giga<becquerel>;
+constexpr auto TBq = tera<becquerel>;
+constexpr auto PBq = peta<becquerel>;
+constexpr auto EBq = exa<becquerel>;
+constexpr auto ZBq = zetta<becquerel>;
+constexpr auto YBq = yotta<becquerel>;
+constexpr auto RBq = ronna<becquerel>;
+constexpr auto QBq = quetta<becquerel>;
 
-inline constexpr auto qGy = quecto<gray>;
-inline constexpr auto rGy = ronto<gray>;
-inline constexpr auto yGy = yocto<gray>;
-inline constexpr auto zGy = zepto<gray>;
-inline constexpr auto aGy = atto<gray>;
-inline constexpr auto fGy = femto<gray>;
-inline constexpr auto pGy = pico<gray>;
-inline constexpr auto nGy = nano<gray>;
-inline constexpr auto uGy = micro<gray>;
-inline constexpr auto mGy = milli<gray>;
-inline constexpr auto cGy = centi<gray>;
-inline constexpr auto dGy = deci<gray>;
-inline constexpr auto Gy = gray;
-inline constexpr auto daGy = deca<gray>;
-inline constexpr auto hGy = hecto<gray>;
-inline constexpr auto kGy = kilo<gray>;
-inline constexpr auto MGy = mega<gray>;
-inline constexpr auto GGy = giga<gray>;
-inline constexpr auto TGy = tera<gray>;
-inline constexpr auto PGy = peta<gray>;
-inline constexpr auto EGy = exa<gray>;
-inline constexpr auto ZGy = zetta<gray>;
-inline constexpr auto YGy = yotta<gray>;
-inline constexpr auto RGy = ronna<gray>;
-inline constexpr auto QGy = quetta<gray>;
+constexpr auto qGy = quecto<gray>;
+constexpr auto rGy = ronto<gray>;
+constexpr auto yGy = yocto<gray>;
+constexpr auto zGy = zepto<gray>;
+constexpr auto aGy = atto<gray>;
+constexpr auto fGy = femto<gray>;
+constexpr auto pGy = pico<gray>;
+constexpr auto nGy = nano<gray>;
+constexpr auto uGy = micro<gray>;
+constexpr auto mGy = milli<gray>;
+constexpr auto cGy = centi<gray>;
+constexpr auto dGy = deci<gray>;
+constexpr auto Gy = gray;
+constexpr auto daGy = deca<gray>;
+constexpr auto hGy = hecto<gray>;
+constexpr auto kGy = kilo<gray>;
+constexpr auto MGy = mega<gray>;
+constexpr auto GGy = giga<gray>;
+constexpr auto TGy = tera<gray>;
+constexpr auto PGy = peta<gray>;
+constexpr auto EGy = exa<gray>;
+constexpr auto ZGy = zetta<gray>;
+constexpr auto YGy = yotta<gray>;
+constexpr auto RGy = ronna<gray>;
+constexpr auto QGy = quetta<gray>;
 
-inline constexpr auto qSv = quecto<sievert>;
-inline constexpr auto rSv = ronto<sievert>;
-inline constexpr auto ySv = yocto<sievert>;
-inline constexpr auto zSv = zepto<sievert>;
-inline constexpr auto aSv = atto<sievert>;
-inline constexpr auto fSv = femto<sievert>;
-inline constexpr auto pSv = pico<sievert>;
-inline constexpr auto nSv = nano<sievert>;
-inline constexpr auto uSv = micro<sievert>;
-inline constexpr auto mSv = milli<sievert>;
-inline constexpr auto cSv = centi<sievert>;
-inline constexpr auto dSv = deci<sievert>;
-inline constexpr auto Sv = sievert;
-inline constexpr auto daSv = deca<sievert>;
-inline constexpr auto hSv = hecto<sievert>;
-inline constexpr auto kSv = kilo<sievert>;
-inline constexpr auto MSv = mega<sievert>;
-inline constexpr auto GSv = giga<sievert>;
-inline constexpr auto TSv = tera<sievert>;
-inline constexpr auto PSv = peta<sievert>;
-inline constexpr auto ESv = exa<sievert>;
-inline constexpr auto ZSv = zetta<sievert>;
-inline constexpr auto YSv = yotta<sievert>;
-inline constexpr auto RSv = ronna<sievert>;
-inline constexpr auto QSv = quetta<sievert>;
+constexpr auto qSv = quecto<sievert>;
+constexpr auto rSv = ronto<sievert>;
+constexpr auto ySv = yocto<sievert>;
+constexpr auto zSv = zepto<sievert>;
+constexpr auto aSv = atto<sievert>;
+constexpr auto fSv = femto<sievert>;
+constexpr auto pSv = pico<sievert>;
+constexpr auto nSv = nano<sievert>;
+constexpr auto uSv = micro<sievert>;
+constexpr auto mSv = milli<sievert>;
+constexpr auto cSv = centi<sievert>;
+constexpr auto dSv = deci<sievert>;
+constexpr auto Sv = sievert;
+constexpr auto daSv = deca<sievert>;
+constexpr auto hSv = hecto<sievert>;
+constexpr auto kSv = kilo<sievert>;
+constexpr auto MSv = mega<sievert>;
+constexpr auto GSv = giga<sievert>;
+constexpr auto TSv = tera<sievert>;
+constexpr auto PSv = peta<sievert>;
+constexpr auto ESv = exa<sievert>;
+constexpr auto ZSv = zetta<sievert>;
+constexpr auto YSv = yotta<sievert>;
+constexpr auto RSv = ronna<sievert>;
+constexpr auto QSv = quetta<sievert>;
 
-inline constexpr auto qkat = quecto<katal>;
-inline constexpr auto rkat = ronto<katal>;
-inline constexpr auto ykat = yocto<katal>;
-inline constexpr auto zkat = zepto<katal>;
-inline constexpr auto akat = atto<katal>;
-inline constexpr auto fkat = femto<katal>;
-inline constexpr auto pkat = pico<katal>;
-inline constexpr auto nkat = nano<katal>;
-inline constexpr auto ukat = micro<katal>;
-inline constexpr auto mkat = milli<katal>;
-inline constexpr auto ckat = centi<katal>;
-inline constexpr auto dkat = deci<katal>;
-inline constexpr auto kat = katal;
-inline constexpr auto dakat = deca<katal>;
-inline constexpr auto hkat = hecto<katal>;
-inline constexpr auto kkat = kilo<katal>;
-inline constexpr auto Mkat = mega<katal>;
-inline constexpr auto Gkat = giga<katal>;
-inline constexpr auto Tkat = tera<katal>;
-inline constexpr auto Pkat = peta<katal>;
-inline constexpr auto Ekat = exa<katal>;
-inline constexpr auto Zkat = zetta<katal>;
-inline constexpr auto Ykat = yotta<katal>;
-inline constexpr auto Rkat = ronna<katal>;
-inline constexpr auto Qkat = quetta<katal>;
+constexpr auto qkat = quecto<katal>;
+constexpr auto rkat = ronto<katal>;
+constexpr auto ykat = yocto<katal>;
+constexpr auto zkat = zepto<katal>;
+constexpr auto akat = atto<katal>;
+constexpr auto fkat = femto<katal>;
+constexpr auto pkat = pico<katal>;
+constexpr auto nkat = nano<katal>;
+constexpr auto ukat = micro<katal>;
+constexpr auto mkat = milli<katal>;
+constexpr auto ckat = centi<katal>;
+constexpr auto dkat = deci<katal>;
+constexpr auto kat = katal;
+constexpr auto dakat = deca<katal>;
+constexpr auto hkat = hecto<katal>;
+constexpr auto kkat = kilo<katal>;
+constexpr auto Mkat = mega<katal>;
+constexpr auto Gkat = giga<katal>;
+constexpr auto Tkat = tera<katal>;
+constexpr auto Pkat = peta<katal>;
+constexpr auto Ekat = exa<katal>;
+constexpr auto Zkat = zetta<katal>;
+constexpr auto Ykat = yotta<katal>;
+constexpr auto Rkat = ronna<katal>;
+constexpr auto Qkat = quetta<katal>;
 
 // no prefixes should be provided for the below units
-inline constexpr auto deg_C = degree_Celsius;
+constexpr auto deg_C = degree_Celsius;
 
 // commonly used squared and cubic units
-inline constexpr auto m2 = square(metre);
-inline constexpr auto m3 = cubic(metre);
-inline constexpr auto m4 = pow<4>(metre);
-inline constexpr auto s2 = square(second);
-inline constexpr auto s3 = cubic(second);
+constexpr auto m2 = square(metre);
+constexpr auto m3 = cubic(metre);
+constexpr auto m4 = pow<4>(metre);
+constexpr auto s2 = square(second);
+constexpr auto s3 = cubic(second);
 
 }  // namespace si::unit_symbols
 
 namespace non_si::unit_symbols {
 
 // TODO Should the following non-SI units have prefixed symbols predefiend as well?
-inline constexpr auto au = astronomical_unit;
-inline constexpr auto deg = degree;
-inline constexpr auto arcmin = arcminute;
-inline constexpr auto arcsec = arcsecond;
-inline constexpr auto a = are;
-inline constexpr auto ha = hectare;
-inline constexpr auto l = litre;
-inline constexpr auto t = tonne;
-inline constexpr auto Da = dalton;
-inline constexpr auto eV = electronvolt;
+constexpr auto au = astronomical_unit;
+constexpr auto deg = degree;
+constexpr auto arcmin = arcminute;
+constexpr auto arcsec = arcsecond;
+constexpr auto a = are;
+constexpr auto ha = hectare;
+constexpr auto l = litre;
+constexpr auto t = tonne;
+constexpr auto Da = dalton;
+constexpr auto eV = electronvolt;
 
 // no prefixes should be provided for the below units
-inline constexpr auto min = minute;
-inline constexpr auto h = hour;
-inline constexpr auto d = day;
+constexpr auto min = minute;
+constexpr auto h = hour;
+constexpr auto d = day;
 
 }  // namespace non_si::unit_symbols
 
diff --git a/src/systems/include/mp-units/systems/si/units.h b/src/systems/include/mp-units/systems/si/units.h
index 4f5efe52..9b464c98 100644
--- a/src/systems/include/mp-units/systems/si/units.h
+++ b/src/systems/include/mp-units/systems/si/units.h
@@ -39,55 +39,55 @@ namespace si {
 
 // clang-format off
 // base units
-inline constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
-inline constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
-inline constexpr struct gram final : named_unit<"g", kind_of<isq::mass>> {} gram;
-inline constexpr auto kilogram = kilo<gram>;
-inline constexpr struct ampere final : named_unit<"A", kind_of<isq::electric_current>> {} ampere;
+constexpr struct second final : named_unit<"s", kind_of<isq::time>> {} second;
+constexpr struct metre final : named_unit<"m", kind_of<isq::length>> {} metre;
+constexpr struct gram final : named_unit<"g", kind_of<isq::mass>> {} gram;
+constexpr auto kilogram = kilo<gram>;
+constexpr struct ampere final : named_unit<"A", kind_of<isq::electric_current>> {} ampere;
 
-inline constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
-inline constexpr auto zeroth_kelvin  = absolute_zero;
-inline constexpr struct kelvin final : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
+constexpr struct absolute_zero final : absolute_point_origin<isq::thermodynamic_temperature> {} absolute_zero;
+constexpr auto zeroth_kelvin  = absolute_zero;
+constexpr struct kelvin final : named_unit<"K", kind_of<isq::thermodynamic_temperature>, zeroth_kelvin> {} kelvin;
 
-inline constexpr struct mole final : named_unit<"mol", kind_of<isq::amount_of_substance>> {} mole;
-inline constexpr struct candela final : named_unit<"cd", kind_of<isq::luminous_intensity>> {} candela;
+constexpr struct mole final : named_unit<"mol", kind_of<isq::amount_of_substance>> {} mole;
+constexpr struct candela final : named_unit<"cd", kind_of<isq::luminous_intensity>> {} candela;
 
 // derived named units
-inline constexpr struct radian final : named_unit<"rad", metre / metre, kind_of<isq::angular_measure>> {} radian;
-inline constexpr struct steradian final : named_unit<"sr", square(metre) / square(metre), kind_of<isq::solid_angular_measure>> {} steradian;
-inline constexpr struct hertz final : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
-inline constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+constexpr struct radian final : named_unit<"rad", metre / metre, kind_of<isq::angular_measure>> {} radian;
+constexpr struct steradian final : named_unit<"sr", square(metre) / square(metre), kind_of<isq::solid_angular_measure>> {} steradian;
+constexpr struct hertz final : named_unit<"Hz", one / second, kind_of<isq::frequency>> {} hertz;
+constexpr struct newton final : named_unit<"N", kilogram * metre / square(second)> {} newton;
 #ifdef pascal
 #pragma push_macro("pascal")
 #undef pascal
 #define MP_UNITS_REDEFINE_PASCAL
 #endif
-inline constexpr struct pascal final : named_unit<"Pa", newton / square(metre)> {} pascal;
+constexpr struct pascal final : named_unit<"Pa", newton / square(metre)> {} pascal;
 #ifdef MP_UNITS_REDEFINE_PASCAL
 #pragma pop_macro("pascal")
 #undef MP_UNITS_REDEFINE_PASCAL
 #endif
-inline constexpr struct joule final : named_unit<"J", newton * metre> {} joule;
-inline constexpr struct watt final : named_unit<"W", joule / second> {} watt;
-inline constexpr struct coulomb final : named_unit<"C", ampere * second> {} coulomb;
-inline constexpr struct volt final : named_unit<"V", watt / ampere> {} volt;
-inline constexpr struct farad final : named_unit<"F", coulomb / volt> {} farad;
-inline constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
-inline constexpr struct siemens final : named_unit<"S", one / ohm> {} siemens;
-inline constexpr struct weber final : named_unit<"Wb", volt * second> {} weber;
-inline constexpr struct tesla final : named_unit<"T", weber / square(metre)> {} tesla;
-inline constexpr struct henry final : named_unit<"H", weber / ampere> {} henry;
+constexpr struct joule final : named_unit<"J", newton * metre> {} joule;
+constexpr struct watt final : named_unit<"W", joule / second> {} watt;
+constexpr struct coulomb final : named_unit<"C", ampere * second> {} coulomb;
+constexpr struct volt final : named_unit<"V", watt / ampere> {} volt;
+constexpr struct farad final : named_unit<"F", coulomb / volt> {} farad;
+constexpr struct ohm final : named_unit<symbol_text{u8"Ω", "ohm"}, volt / ampere> {} ohm;
+constexpr struct siemens final : named_unit<"S", one / ohm> {} siemens;
+constexpr struct weber final : named_unit<"Wb", volt * second> {} weber;
+constexpr struct tesla final : named_unit<"T", weber / square(metre)> {} tesla;
+constexpr struct henry final : named_unit<"H", weber / ampere> {} henry;
 
-inline constexpr struct ice_point final : relative_point_origin<absolute<milli<kelvin>>(273'150)> {} ice_point;
-inline constexpr auto zeroth_degree_Celsius = ice_point;
-inline constexpr struct degree_Celsius final : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
+constexpr struct ice_point final : relative_point_origin<absolute<milli<kelvin>>(273'150)> {} ice_point;
+constexpr auto zeroth_degree_Celsius = ice_point;
+constexpr struct degree_Celsius final : named_unit<symbol_text{u8"℃", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
 
-inline constexpr struct lumen final : named_unit<"lm", candela * steradian> {} lumen;
-inline constexpr struct lux final : named_unit<"lx", lumen / square(metre)> {} lux;
-inline constexpr struct becquerel final : named_unit<"Bq", one / second, kind_of<isq::activity>> {} becquerel;
-inline constexpr struct gray final : named_unit<"Gy", joule / kilogram, kind_of<isq::absorbed_dose>> {} gray;
-inline constexpr struct sievert final : named_unit<"Sv", joule / kilogram, kind_of<isq::dose_equivalent>> {} sievert;
-inline constexpr struct katal final : named_unit<"kat", mole / second> {} katal;
+constexpr struct lumen final : named_unit<"lm", candela * steradian> {} lumen;
+constexpr struct lux final : named_unit<"lx", lumen / square(metre)> {} lux;
+constexpr struct becquerel final : named_unit<"Bq", one / second, kind_of<isq::activity>> {} becquerel;
+constexpr struct gray final : named_unit<"Gy", joule / kilogram, kind_of<isq::absorbed_dose>> {} gray;
+constexpr struct sievert final : named_unit<"Sv", joule / kilogram, kind_of<isq::dose_equivalent>> {} sievert;
+constexpr struct katal final : named_unit<"kat", mole / second> {} katal;
 // clang-format on
 
 }  // namespace si
@@ -96,20 +96,20 @@ namespace non_si {
 
 // clang-format off
 // non-SI units accepted for use with the SI
-inline constexpr struct minute final : named_unit<"min", mag<60> * si::second> {} minute;
-inline constexpr struct hour final : named_unit<"h", mag<60> * minute> {} hour;
-inline constexpr struct day final : named_unit<"d", mag<24> * hour> {} day;
-inline constexpr struct astronomical_unit final : named_unit<"au", mag<149'597'870'700> * si::metre> {} astronomical_unit;
-inline constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
-inline constexpr struct arcminute final : named_unit<symbol_text{u8"′", "'"}, mag_ratio<1, 60> * degree> {} arcminute;
-inline constexpr struct arcsecond final : named_unit<symbol_text{u8"″", "''"}, mag_ratio<1, 60> * arcminute> {} arcsecond;
-inline constexpr struct are final : named_unit<"a", square(si::deca<si::metre>)> {} are;
-inline constexpr auto hectare = si::hecto<are>;
-inline constexpr struct litre final : named_unit<"l", cubic(si::deci<si::metre>)> {} litre;
-inline constexpr struct tonne final : named_unit<"t", mag<1000> * si::kilogram> {} tonne;
-inline constexpr struct dalton final : named_unit<"Da", mag_ratio<16'605'390'666'050, 10'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} dalton;
+constexpr struct minute final : named_unit<"min", mag<60> * si::second> {} minute;
+constexpr struct hour final : named_unit<"h", mag<60> * minute> {} hour;
+constexpr struct day final : named_unit<"d", mag<24> * hour> {} day;
+constexpr struct astronomical_unit final : named_unit<"au", mag<149'597'870'700> * si::metre> {} astronomical_unit;
+constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * si::radian> {} degree;
+constexpr struct arcminute final : named_unit<symbol_text{u8"′", "'"}, mag_ratio<1, 60> * degree> {} arcminute;
+constexpr struct arcsecond final : named_unit<symbol_text{u8"″", "''"}, mag_ratio<1, 60> * arcminute> {} arcsecond;
+constexpr struct are final : named_unit<"a", square(si::deca<si::metre>)> {} are;
+constexpr auto hectare = si::hecto<are>;
+constexpr struct litre final : named_unit<"l", cubic(si::deci<si::metre>)> {} litre;
+constexpr struct tonne final : named_unit<"t", mag<1000> * si::kilogram> {} tonne;
+constexpr struct dalton final : named_unit<"Da", mag_ratio<16'605'390'666'050, 10'000'000'000'000> * mag_power<10, -27> * si::kilogram> {} dalton;
 // TODO A different value is provided in the SI Brochure and different in the ISO 80000
-inline constexpr struct electronvolt final : named_unit<"eV", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * si::joule> {} electronvolt;
+constexpr struct electronvolt final : named_unit<"eV", mag_ratio<1'602'176'634, 1'000'000'000> * mag_power<10, -19> * si::joule> {} electronvolt;
 // TODO the below are logarithmic units - how to support those?
 // neper
 // bel
@@ -126,10 +126,10 @@ using namespace non_si;
 }  // namespace si
 
 template<>
-inline constexpr bool space_before_unit_symbol<non_si::degree> = false;
+constexpr bool space_before_unit_symbol<non_si::degree> = false;
 template<>
-inline constexpr bool space_before_unit_symbol<non_si::arcminute> = false;
+constexpr bool space_before_unit_symbol<non_si::arcminute> = false;
 template<>
-inline constexpr bool space_before_unit_symbol<non_si::arcsecond> = false;
+constexpr bool space_before_unit_symbol<non_si::arcsecond> = false;
 
 }  // namespace mp_units
diff --git a/src/systems/include/mp-units/systems/typographic.h b/src/systems/include/mp-units/systems/typographic.h
index f368d350..6969d594 100644
--- a/src/systems/include/mp-units/systems/typographic.h
+++ b/src/systems/include/mp-units/systems/typographic.h
@@ -36,11 +36,11 @@ namespace mp_units::typographic {
 
 // clang-format off
 // https://en.wikipedia.org/wiki/Point_(typography)
-inline constexpr struct pica_us final : named_unit<"pica(us)", mag_ratio<166'044, 1'000'000> * international::inch> {} pica_us;
-inline constexpr struct point_us final : named_unit<"point(us)", mag_ratio<1, 12> * pica_us> {} point_us;
+constexpr struct pica_us final : named_unit<"pica(us)", mag_ratio<166'044, 1'000'000> * international::inch> {} pica_us;
+constexpr struct point_us final : named_unit<"point(us)", mag_ratio<1, 12> * pica_us> {} point_us;
 
-inline constexpr struct point_dtp final : named_unit<"point(dtp)", mag_ratio<1, 72> * international::inch> {} point_dtp;
-inline constexpr struct pica_dtp final : named_unit<"pica(dtp)", mag<12> * point_dtp> {} pica_dtp;
+constexpr struct point_dtp final : named_unit<"point(dtp)", mag_ratio<1, 72> * international::inch> {} point_dtp;
+constexpr struct pica_dtp final : named_unit<"pica(dtp)", mag<12> * point_dtp> {} pica_dtp;
 // clang-format on
 
 }  // namespace mp_units::typographic
diff --git a/src/systems/include/mp-units/systems/usc.h b/src/systems/include/mp-units/systems/usc.h
index cca91973..8214d7c4 100644
--- a/src/systems/include/mp-units/systems/usc.h
+++ b/src/systems/include/mp-units/systems/usc.h
@@ -41,78 +41,78 @@ using namespace international;
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Length
 // nautical
-inline constexpr struct fathom final : named_unit<"ftm(us)", mag<2> * yard> {} fathom;
-inline constexpr struct cable final : named_unit<"cb(us)", mag<120> * fathom> {} cable;
+constexpr struct fathom final : named_unit<"ftm(us)", mag<2> * yard> {} fathom;
+constexpr struct cable final : named_unit<"cb(us)", mag<120> * fathom> {} cable;
 
 // survey
 struct us_survey_foot final : named_unit<"ft(us)", mag_ratio<1'200, 3'937> * si::metre> {};
 struct us_survey_mile final : named_unit<"mi(us)", mag<5280> * us_survey_foot{}> {};
 
 [[deprecated("In accordance with NIST SP 811, as of January 1, 2023, the use of the U.S. survey foot and U.S. survey mile is deprecated.")]]
-inline constexpr us_survey_foot us_survey_foot;
+constexpr us_survey_foot us_survey_foot;
 
 [[deprecated("In accordance with NIST SP 811, as of January 1, 2023, the use of the U.S. survey foot and U.S. survey mile is deprecated.")]]
-inline constexpr us_survey_mile us_survey_mile;
+constexpr us_survey_mile us_survey_mile;
 
-inline constexpr struct link final : named_unit<"li", mag_ratio<33, 50> * foot> {} link;
-inline constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
-inline constexpr struct chain final : named_unit<"ch", mag<4> * rod> {} chain;
-inline constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
+constexpr struct link final : named_unit<"li", mag_ratio<33, 50> * foot> {} link;
+constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
+constexpr struct chain final : named_unit<"ch", mag<4> * rod> {} chain;
+constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
 // clang-format on
 
 namespace survey1893 {
 
 // clang-format off
-inline constexpr struct us_survey_foot final : named_unit<"ft(us)", mag_ratio<1'200, 3'937> * si::metre> {} us_survey_foot;
-inline constexpr struct link final : named_unit<"li", mag_ratio<33, 50> * us_survey_foot> {} link;
-inline constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
-inline constexpr struct chain final : named_unit<"ch", mag<4> * rod> {} chain;
-inline constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
-inline constexpr struct us_survey_mile final : named_unit<"mi(us)", mag<8> * furlong> {} us_survey_mile;
-inline constexpr struct league final : named_unit<"lea", mag<3> * us_survey_mile> {} league;
+constexpr struct us_survey_foot final : named_unit<"ft(us)", mag_ratio<1'200, 3'937> * si::metre> {} us_survey_foot;
+constexpr struct link final : named_unit<"li", mag_ratio<33, 50> * us_survey_foot> {} link;
+constexpr struct rod final : named_unit<"rd", mag<25> * link> {} rod;
+constexpr struct chain final : named_unit<"ch", mag<4> * rod> {} chain;
+constexpr struct furlong final : named_unit<"fur", mag<10> * chain> {} furlong;
+constexpr struct us_survey_mile final : named_unit<"mi(us)", mag<8> * furlong> {} us_survey_mile;
+constexpr struct league final : named_unit<"lea", mag<3> * us_survey_mile> {} league;
 // clang-format on
 
 }  // namespace survey1893
 
 // clang-format off
 // https://en.wikipedia.org/wiki/United_States_customary_units#Area
-inline constexpr struct acre final : named_unit<"acre", mag<10> * square(survey1893::chain)> {} acre;
-inline constexpr struct section final : named_unit<"section", mag<640> * acre> {} section;
+constexpr struct acre final : named_unit<"acre", mag<10> * square(survey1893::chain)> {} acre;
+constexpr struct section final : named_unit<"section", mag<640> * acre> {} section;
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Fluid_volume
-inline constexpr struct gallon final : named_unit<"gal", mag<231> * cubic(inch)> {} gallon;
-inline constexpr struct pottle final : named_unit<"pot", mag_ratio<1, 2> * gallon> {} pottle;
-inline constexpr struct quart final : named_unit<"qt", mag_ratio<1, 2> * pottle> {} quart;
-inline constexpr struct pint final : named_unit<"pt", mag_ratio<1, 2> * quart> {} pint;
-inline constexpr struct cup final : named_unit<"c", mag_ratio<1, 2> * pint> {} cup;
-inline constexpr struct gill final : named_unit<"gi", mag_ratio<1, 2> * cup> {} gill;
-inline constexpr struct fluid_ounce final : named_unit<"fl oz", mag_ratio<1, 4> * gill> {} fluid_ounce;
-inline constexpr struct tablespoon final : named_unit<"tbsp", mag_ratio<1, 2> * fluid_ounce> {} tablespoon;
-inline constexpr struct shot final : named_unit<"jig", mag<3> * tablespoon> {} shot;
-inline constexpr struct teaspoon final : named_unit<"tsp", mag_ratio<1, 3> * tablespoon> {} teaspoon;
-inline constexpr struct minim final : named_unit<"min", mag_ratio<1, 80> * teaspoon> {} minim;
-inline constexpr struct fluid_dram final : named_unit<"fl dr", mag<60> * minim> {} fluid_dram;
-inline constexpr struct barrel final : named_unit<"bbl", mag_ratio<315, 10> * gallon> {} barrel;
-inline constexpr struct oil_barrel final : named_unit<"bbl", mag_ratio<4, 3> * barrel> {} oil_barrel;
-inline constexpr struct hogshead final : named_unit<"hogshead", mag<63> * gallon> {} hogshead;
+constexpr struct gallon final : named_unit<"gal", mag<231> * cubic(inch)> {} gallon;
+constexpr struct pottle final : named_unit<"pot", mag_ratio<1, 2> * gallon> {} pottle;
+constexpr struct quart final : named_unit<"qt", mag_ratio<1, 2> * pottle> {} quart;
+constexpr struct pint final : named_unit<"pt", mag_ratio<1, 2> * quart> {} pint;
+constexpr struct cup final : named_unit<"c", mag_ratio<1, 2> * pint> {} cup;
+constexpr struct gill final : named_unit<"gi", mag_ratio<1, 2> * cup> {} gill;
+constexpr struct fluid_ounce final : named_unit<"fl oz", mag_ratio<1, 4> * gill> {} fluid_ounce;
+constexpr struct tablespoon final : named_unit<"tbsp", mag_ratio<1, 2> * fluid_ounce> {} tablespoon;
+constexpr struct shot final : named_unit<"jig", mag<3> * tablespoon> {} shot;
+constexpr struct teaspoon final : named_unit<"tsp", mag_ratio<1, 3> * tablespoon> {} teaspoon;
+constexpr struct minim final : named_unit<"min", mag_ratio<1, 80> * teaspoon> {} minim;
+constexpr struct fluid_dram final : named_unit<"fl dr", mag<60> * minim> {} fluid_dram;
+constexpr struct barrel final : named_unit<"bbl", mag_ratio<315, 10> * gallon> {} barrel;
+constexpr struct oil_barrel final : named_unit<"bbl", mag_ratio<4, 3> * barrel> {} oil_barrel;
+constexpr struct hogshead final : named_unit<"hogshead", mag<63> * gallon> {} hogshead;
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Dry_volume
-inline constexpr struct dry_barrel final : named_unit<"bbl", mag<7056> * cubic(inch)> {} dry_barrel;
-inline constexpr struct bushel final : named_unit<"bu", mag_ratio<3'523'907'016'688, 100'000'000'000> * si::litre> {} bushel;
-inline constexpr struct peck final : named_unit<"pk", mag_ratio<1, 4> * bushel> {} peck;
-inline constexpr struct dry_gallon final : named_unit<"gal", mag_ratio<1, 2> * peck> {} dry_gallon;
-inline constexpr struct dry_quart final : named_unit<"qt", mag_ratio<1, 4> * dry_gallon> {} dry_quart;
-inline constexpr struct dry_pint final : named_unit<"pt", mag_ratio<1, 2> * dry_quart> {} dry_pint;
+constexpr struct dry_barrel final : named_unit<"bbl", mag<7056> * cubic(inch)> {} dry_barrel;
+constexpr struct bushel final : named_unit<"bu", mag_ratio<3'523'907'016'688, 100'000'000'000> * si::litre> {} bushel;
+constexpr struct peck final : named_unit<"pk", mag_ratio<1, 4> * bushel> {} peck;
+constexpr struct dry_gallon final : named_unit<"gal", mag_ratio<1, 2> * peck> {} dry_gallon;
+constexpr struct dry_quart final : named_unit<"qt", mag_ratio<1, 4> * dry_gallon> {} dry_quart;
+constexpr struct dry_pint final : named_unit<"pt", mag_ratio<1, 2> * dry_quart> {} dry_pint;
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Mass_and_Weight
 // https://en.wikipedia.org/wiki/Avoirdupois_system#American_customary_system
-inline constexpr struct quarter final : named_unit<"qr", mag<25> * pound> {} quarter;
-inline constexpr struct short_hundredweight final : named_unit<"cwt", mag<100> * pound> {} short_hundredweight;
-inline constexpr struct ton final : named_unit<"t", mag<2'000> * pound> {} ton;
-inline constexpr auto short_ton = ton;
-inline constexpr struct pennyweight final : named_unit<"dwt", mag<24> * grain> {} pennyweight;
-inline constexpr struct troy_once final : named_unit<"oz t", mag<20> * pennyweight> {} troy_once;
-inline constexpr struct troy_pound final : named_unit<"lb t", mag<12> * troy_once> {} troy_pound;
+constexpr struct quarter final : named_unit<"qr", mag<25> * pound> {} quarter;
+constexpr struct short_hundredweight final : named_unit<"cwt", mag<100> * pound> {} short_hundredweight;
+constexpr struct ton final : named_unit<"t", mag<2'000> * pound> {} ton;
+constexpr auto short_ton = ton;
+constexpr struct pennyweight final : named_unit<"dwt", mag<24> * grain> {} pennyweight;
+constexpr struct troy_once final : named_unit<"oz t", mag<20> * pennyweight> {} troy_once;
+constexpr struct troy_pound final : named_unit<"lb t", mag<12> * troy_once> {} troy_pound;
 
 // https://en.wikipedia.org/wiki/Inch_of_mercury
 #ifdef pascal
@@ -120,15 +120,15 @@ inline constexpr struct troy_pound final : named_unit<"lb t", mag<12> * troy_onc
 #undef pascal
 #define MP_UNITS_REDEFINE_PASCAL
 #endif
-inline constexpr struct inch_of_mercury final : named_unit<"inHg", mag_ratio<3'386'389, 1'000> * si::pascal> {} inch_of_mercury;
+constexpr struct inch_of_mercury final : named_unit<"inHg", mag_ratio<3'386'389, 1'000> * si::pascal> {} inch_of_mercury;
 #ifdef MP_UNITS_REDEFINE_PASCAL
 #pragma pop_macro("pascal")
 #undef MP_UNITS_REDEFINE_PASCAL
 #endif
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Temperature
-inline constexpr struct zeroth_degree_Fahrenheit final : relative_point_origin<absolute<mag_ratio<5, 9> * si::degree_Celsius>(-32)> {} zeroth_degree_Fahrenheit;
-inline constexpr struct degree_Fahrenheit final : named_unit<symbol_text{u8"℉", "`F"}, mag_ratio<5, 9> * si::degree_Celsius, zeroth_degree_Fahrenheit> {} degree_Fahrenheit;
+constexpr struct zeroth_degree_Fahrenheit final : relative_point_origin<absolute<mag_ratio<5, 9> * si::degree_Celsius>(-32)> {} zeroth_degree_Fahrenheit;
+constexpr struct degree_Fahrenheit final : named_unit<symbol_text{u8"℉", "`F"}, mag_ratio<5, 9> * si::degree_Celsius, zeroth_degree_Fahrenheit> {} degree_Fahrenheit;
 
 // clang-format on
 
@@ -136,51 +136,51 @@ namespace unit_symbols {
 
 using namespace international::unit_symbols;
 
-inline constexpr auto ftm = fathom;
-inline constexpr auto cb = cable;
+constexpr auto ftm = fathom;
+constexpr auto cb = cable;
 [[deprecated(
   "In accordance with NIST SP 811, as of January 1, 2023, the use of the U.S. survey foot and U.S. survey mile is "
-  "deprecated.")]] inline constexpr struct us_survey_foot us_ft;
+  "deprecated.")]] constexpr struct us_survey_foot us_ft;
 [[deprecated(
   "In accordance with NIST SP 811, as of January 1, 2023, the use of the U.S. survey foot and U.S. survey mile is "
-  "deprecated.")]] inline constexpr struct us_survey_mile us_mi;
-inline constexpr auto li = link;
-inline constexpr auto rd = rod;
-inline constexpr auto ch = chain;
-inline constexpr auto fur = furlong;
-inline constexpr auto lea = league;
+  "deprecated.")]] constexpr struct us_survey_mile us_mi;
+constexpr auto li = link;
+constexpr auto rd = rod;
+constexpr auto ch = chain;
+constexpr auto fur = furlong;
+constexpr auto lea = league;
 
-inline constexpr auto gal = gallon;
-inline constexpr auto pot = pottle;
-inline constexpr auto qt = quart;
-inline constexpr auto pt = pint;
-inline constexpr auto c = cup;
-inline constexpr auto gi = gill;
-inline constexpr auto fl_oz = fluid_ounce;
-inline constexpr auto tbsp = tablespoon;
-inline constexpr auto jig = shot;
-inline constexpr auto tsp = teaspoon;
-inline constexpr auto min = minim;
-inline constexpr auto fl_dr = fluid_dram;
-inline constexpr auto bbl = barrel;
+constexpr auto gal = gallon;
+constexpr auto pot = pottle;
+constexpr auto qt = quart;
+constexpr auto pt = pint;
+constexpr auto c = cup;
+constexpr auto gi = gill;
+constexpr auto fl_oz = fluid_ounce;
+constexpr auto tbsp = tablespoon;
+constexpr auto jig = shot;
+constexpr auto tsp = teaspoon;
+constexpr auto min = minim;
+constexpr auto fl_dr = fluid_dram;
+constexpr auto bbl = barrel;
 
-inline constexpr auto dry_bbl = dry_barrel;
-inline constexpr auto bu = bushel;
-inline constexpr auto pk = peck;
-inline constexpr auto dry_gal = dry_gallon;
-inline constexpr auto dry_qt = dry_quart;
-inline constexpr auto dry_pt = dry_pint;
+constexpr auto dry_bbl = dry_barrel;
+constexpr auto bu = bushel;
+constexpr auto pk = peck;
+constexpr auto dry_gal = dry_gallon;
+constexpr auto dry_qt = dry_quart;
+constexpr auto dry_pt = dry_pint;
 
-inline constexpr auto qr = quarter;
-inline constexpr auto cwt = short_hundredweight;
-inline constexpr auto t = ton;
-inline constexpr auto dwt = pennyweight;
-inline constexpr auto oz_t = troy_once;
-inline constexpr auto lb_t = troy_pound;
+constexpr auto qr = quarter;
+constexpr auto cwt = short_hundredweight;
+constexpr auto t = ton;
+constexpr auto dwt = pennyweight;
+constexpr auto oz_t = troy_once;
+constexpr auto lb_t = troy_pound;
 
-inline constexpr auto inHg = inch_of_mercury;
+constexpr auto inHg = inch_of_mercury;
 
-inline constexpr auto deg_F = degree_Fahrenheit;
+constexpr auto deg_F = degree_Fahrenheit;
 
 }  // namespace unit_symbols
 
diff --git a/test/runtime/fmt_test.cpp b/test/runtime/fmt_test.cpp
index 7df94d90..5cf76786 100644
--- a/test/runtime/fmt_test.cpp
+++ b/test/runtime/fmt_test.cpp
@@ -50,7 +50,7 @@ import mp_units;
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 using namespace mp_units;
 using namespace mp_units::si::unit_symbols;
diff --git a/test/runtime/linear_algebra_test.cpp b/test/runtime/linear_algebra_test.cpp
index 0a8e8ef7..4799decd 100644
--- a/test/runtime/linear_algebra_test.cpp
+++ b/test/runtime/linear_algebra_test.cpp
@@ -44,10 +44,10 @@ template<typename Rep = double>
 using vector = STD_LA::fixed_size_column_vector<Rep, 3>;
 
 template<class Rep>
-inline constexpr bool mp_units::treat_as_floating_point<vector<Rep>> = mp_units::treat_as_floating_point<Rep>;
+constexpr bool mp_units::treat_as_floating_point<vector<Rep>> = mp_units::treat_as_floating_point<Rep>;
 
 template<typename Rep>
-inline constexpr bool mp_units::is_vector<vector<Rep>> = true;
+constexpr bool mp_units::is_vector<vector<Rep>> = true;
 
 template<typename Rep>
 std::ostream& operator<<(std::ostream& os, const vector<Rep>& v)
@@ -301,7 +301,7 @@ TEST_CASE("vector quantity", "[la]")
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 TEST_CASE("vector of quantities", "[la]")
 {
diff --git a/test/runtime/truncation_test.cpp b/test/runtime/truncation_test.cpp
index 3ff10046..2626c583 100644
--- a/test/runtime/truncation_test.cpp
+++ b/test/runtime/truncation_test.cpp
@@ -42,9 +42,9 @@ using namespace mp_units;
 using namespace mp_units::angular;
 using namespace mp_units::angular::unit_symbols;
 
-inline constexpr struct half_revolution final : named_unit<"hrev", mag_pi * radian> {
+constexpr struct half_revolution final : named_unit<"hrev", mag_pi * radian> {
 } half_revolution;
-inline constexpr auto hrev = half_revolution;
+constexpr auto hrev = half_revolution;
 
 // constexpr auto revb6 = mag_ratio<1,3> * mag_pi * rad;
 
diff --git a/test/static/cgs_test.cpp b/test/static/cgs_test.cpp
index 557a8f7a..c027b601 100644
--- a/test/static/cgs_test.cpp
+++ b/test/static/cgs_test.cpp
@@ -28,7 +28,7 @@
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
diff --git a/test/static/concepts_test.cpp b/test/static/concepts_test.cpp
index 06b20699..937776eb 100644
--- a/test/static/concepts_test.cpp
+++ b/test/static/concepts_test.cpp
@@ -37,19 +37,19 @@ import std;
 
 #if MP_UNITS_HOSTED
 template<typename T>
-inline constexpr bool mp_units::is_scalar<std::complex<T>> = true;
+constexpr bool mp_units::is_scalar<std::complex<T>> = true;
 #endif
 
 namespace {
 
 using namespace mp_units;
 
-inline constexpr struct my_origin final : absolute_point_origin<isq::length> {
+constexpr struct my_origin final : absolute_point_origin<isq::length> {
 } my_origin;
-inline constexpr struct my_relative_origin final : relative_point_origin<my_origin + isq::length(42 * si::metre)> {
+constexpr struct my_relative_origin final : relative_point_origin<my_origin + isq::length(42 * si::metre)> {
 } my_relative_origin;
 
-inline constexpr auto dim_speed = isq::dim_length / isq::dim_time;
+constexpr auto dim_speed = isq::dim_length / isq::dim_time;
 
 // BaseDimension
 static_assert(detail::BaseDimension<struct isq::dim_length>);
@@ -78,7 +78,7 @@ static_assert(!Dimension<int>);
 // TODO add tests
 
 // QuantitySpec
-inline constexpr auto speed = isq::length / isq::time;
+constexpr auto speed = isq::length / isq::time;
 
 static_assert(QuantitySpec<struct isq::length>);
 static_assert(QuantitySpec<struct isq::radius>);
diff --git a/test/static/custom_rep_test_min_impl.cpp b/test/static/custom_rep_test_min_impl.cpp
index 8e8c3b7c..4fb2537b 100644
--- a/test/static/custom_rep_test_min_impl.cpp
+++ b/test/static/custom_rep_test_min_impl.cpp
@@ -61,7 +61,7 @@ public:
 }  // namespace
 
 template<typename T>
-inline constexpr bool mp_units::is_scalar<min_impl<T>> = true;
+constexpr bool mp_units::is_scalar<min_impl<T>> = true;
 
 template<typename T, typename U>
 struct std::common_type<min_impl<T>, min_impl<U>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
diff --git a/test/static/dimension_test.cpp b/test/static/dimension_test.cpp
index 8064831e..6d4aa96f 100644
--- a/test/static/dimension_test.cpp
+++ b/test/static/dimension_test.cpp
@@ -36,31 +36,31 @@ using namespace mp_units;
 using dimension_one_ = struct dimension_one;
 
 // clang-format off
-inline constexpr struct length_ final : base_dimension<"L"> {} length;
-inline constexpr struct mass_ final : base_dimension<"M"> {} mass;
-inline constexpr struct time_ final : base_dimension<"T"> {} time;
+constexpr struct length_ final : base_dimension<"L"> {} length;
+constexpr struct mass_ final : base_dimension<"M"> {} mass;
+constexpr struct time_ final : base_dimension<"T"> {} time;
 
-inline constexpr auto my_length1 = length;
-inline constexpr auto my_length2 = length;
+constexpr auto my_length1 = length;
+constexpr auto my_length2 = length;
 
 QUANTITY_SPEC_(q_time, time);
-inline constexpr struct second_ final : named_unit<"s", kind_of<q_time>> {} second;
+constexpr struct second_ final : named_unit<"s", kind_of<q_time>> {} second;
 
-inline constexpr auto frequency = inverse(time);
-inline constexpr auto action = inverse(time);
-inline constexpr auto area = length * length;
-inline constexpr auto volume = area * length;
-inline constexpr auto speed = length / time;
-inline constexpr auto acceleration = speed / time;
-inline constexpr auto force = mass * acceleration;
-inline constexpr auto moment_of_force = length * force;
-inline constexpr auto torque = moment_of_force;
-inline constexpr auto pressure = force / area;
-inline constexpr auto stress = pressure;
-inline constexpr auto strain = stress / stress;
-inline constexpr auto power = force * speed;
-inline constexpr auto efficiency = power / power;
-inline constexpr auto energy = force * length;
+constexpr auto frequency = inverse(time);
+constexpr auto action = inverse(time);
+constexpr auto area = length * length;
+constexpr auto volume = area * length;
+constexpr auto speed = length / time;
+constexpr auto acceleration = speed / time;
+constexpr auto force = mass * acceleration;
+constexpr auto moment_of_force = length * force;
+constexpr auto torque = moment_of_force;
+constexpr auto pressure = force / area;
+constexpr auto stress = pressure;
+constexpr auto strain = stress / stress;
+constexpr auto power = force * speed;
+constexpr auto efficiency = power / power;
+constexpr auto energy = force * length;
 // clang-format on
 
 // concepts verification
diff --git a/test/static/hep_test.cpp b/test/static/hep_test.cpp
index 20316774..62407bd4 100644
--- a/test/static/hep_test.cpp
+++ b/test/static/hep_test.cpp
@@ -26,7 +26,7 @@
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
diff --git a/test/static/international_test.cpp b/test/static/international_test.cpp
index 8dc41168..755eea73 100644
--- a/test/static/international_test.cpp
+++ b/test/static/international_test.cpp
@@ -28,7 +28,7 @@
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
diff --git a/test/static/magnitude_test.cpp b/test/static/magnitude_test.cpp
index f245b0b8..da2dd5cb 100644
--- a/test/static/magnitude_test.cpp
+++ b/test/static/magnitude_test.cpp
@@ -32,7 +32,7 @@ using namespace units;
 using namespace units::detail;
 
 template<>
-inline constexpr std::optional<std::intmax_t> units::known_first_factor<9223372036854775783> = 9223372036854775783;
+constexpr std::optional<std::intmax_t> units::known_first_factor<9223372036854775783> = 9223372036854775783;
 
 namespace {
 
@@ -71,11 +71,11 @@ namespace {
 //   CHECK(round_trip == R);
 // }
 
-inline constexpr struct mag_2_ : magnitude<2> {
+constexpr struct mag_2_ : magnitude<2> {
 } mag_2;
-// inline constexpr struct mag_2_other : magnitude<2> {
+// constexpr struct mag_2_other : magnitude<2> {
 // } mag_2_other;
-// inline constexpr struct mag_3 : magnitude<2> {
+// constexpr struct mag_3 : magnitude<2> {
 // } mag_3;
 
 // concepts verification
diff --git a/test/static/natural_test.cpp b/test/static/natural_test.cpp
index 84e61e9e..9986149a 100644
--- a/test/static/natural_test.cpp
+++ b/test/static/natural_test.cpp
@@ -24,7 +24,7 @@
 
 template<class T>
   requires mp_units::is_scalar<T>
-inline constexpr bool mp_units::is_vector<T> = true;
+constexpr bool mp_units::is_vector<T> = true;
 
 namespace {
 
diff --git a/test/static/quantity_point_test.cpp b/test/static/quantity_point_test.cpp
index 06ad1f16..80a35127 100644
--- a/test/static/quantity_point_test.cpp
+++ b/test/static/quantity_point_test.cpp
@@ -50,38 +50,38 @@ using namespace std::chrono_literals;
 using sys_seconds = std::chrono::time_point<std::chrono::system_clock, std::chrono::seconds>;
 #endif
 
-inline constexpr struct zeroth_length final : absolute_point_origin<isq::length> {
+constexpr struct zeroth_length final : absolute_point_origin<isq::length> {
 } zeroth_length;
 
-inline constexpr struct mean_sea_level final : absolute_point_origin<isq::height> {
+constexpr struct mean_sea_level final : absolute_point_origin<isq::height> {
 } mean_sea_level;
 
-inline constexpr auto my_mean_sea_level = mean_sea_level;
+constexpr auto my_mean_sea_level = mean_sea_level;
 
-inline constexpr struct same_mean_sea_level final : relative_point_origin<mean_sea_level + 0 * isq::height[m]> {
+constexpr struct same_mean_sea_level final : relative_point_origin<mean_sea_level + 0 * isq::height[m]> {
 } same_mean_sea_level;
 
-inline constexpr struct ground_level final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
+constexpr struct ground_level final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
 } ground_level;
 
-inline constexpr auto my_ground_level = ground_level;
+constexpr auto my_ground_level = ground_level;
 
-inline constexpr struct same_ground_level1 final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
+constexpr struct same_ground_level1 final : relative_point_origin<mean_sea_level + 42 * isq::height[m]> {
 } same_ground_level1;
 
-inline constexpr struct same_ground_level2 final : relative_point_origin<my_mean_sea_level + 42 * isq::height[m]> {
+constexpr struct same_ground_level2 final : relative_point_origin<my_mean_sea_level + 42 * isq::height[m]> {
 } same_ground_level2;
 
-inline constexpr struct tower_peak final : relative_point_origin<ground_level + 42 * isq::height[m]> {
+constexpr struct tower_peak final : relative_point_origin<ground_level + 42 * isq::height[m]> {
 } tower_peak;
 
-inline constexpr struct other_ground_level final : relative_point_origin<mean_sea_level + 123 * isq::height[m]> {
+constexpr struct other_ground_level final : relative_point_origin<mean_sea_level + 123 * isq::height[m]> {
 } other_ground_level;
 
-inline constexpr struct other_absolute_level final : absolute_point_origin<isq::height> {
+constexpr struct other_absolute_level final : absolute_point_origin<isq::height> {
 } other_absolute_level;
 
-inline constexpr struct zero final : absolute_point_origin<dimensionless> {
+constexpr struct zero final : absolute_point_origin<dimensionless> {
 } zero;
 
 QUANTITY_SPEC(special_height, isq::height);
@@ -111,18 +111,18 @@ static_assert(ground_level != other_ground_level);
 template<auto QS>
 struct absolute_po_ final : absolute_point_origin<QS> {};
 template<auto QS>
-inline constexpr absolute_po_<QS> absolute_po;
+constexpr absolute_po_<QS> absolute_po;
 
 template<auto QP>
 struct relative_po_ final : relative_point_origin<QP> {};
 template<auto QP>
-inline constexpr relative_po_<QP> relative_po;
+constexpr relative_po_<QP> relative_po;
 
 static_assert(relative_po<absolute_po<isq::length> + isq::height(42 * m)>.quantity_spec == isq::height);
 static_assert(relative_po<absolute_po<kind_of<isq::length>> + isq::height(42 * m)>.quantity_spec == isq::height);
 static_assert(relative_po<absolute_po<isq::height> + 42 * m>.quantity_spec == isq::height);
 
-inline constexpr struct my_kelvin final : named_unit<"my_K", mag<10> * si::kelvin> {
+constexpr struct my_kelvin final : named_unit<"my_K", mag<10> * si::kelvin> {
 } my_kelvin;
 
 static_assert(default_point_origin(si::kelvin) == si::absolute_zero);
@@ -1516,7 +1516,7 @@ static_assert(ground_level - other_ground_level == -81 * m);
 static_assert(other_ground_level - tower_peak == 39 * m);
 static_assert(tower_peak - other_ground_level == -39 * m);
 
-inline constexpr struct zero_m_per_s final : absolute_point_origin<kind_of<isq::speed>> {
+constexpr struct zero_m_per_s final : absolute_point_origin<kind_of<isq::speed>> {
 } zero_m_per_s;
 
 // commutativity and associativity
@@ -1604,7 +1604,7 @@ static_assert(
   is_of_type<quantity_point{10 * isq::height[m] / (2 * isq::time[s])} + (10 * isq::height[m] / (2 * isq::time[s])),
              quantity_point<(isq::height / isq::time)[m / s], zeroth_point_origin<isq::height / isq::time>, int>>);
 
-inline constexpr struct zero_Hz final : absolute_point_origin<kind_of<isq::frequency>> {
+constexpr struct zero_Hz final : absolute_point_origin<kind_of<isq::frequency>> {
 } zero_Hz;
 
 static_assert(((zero_Hz + 10 / (2 * isq::period_duration[s])) + 5 * isq::frequency[Hz]).quantity_from(zero_Hz) ==
@@ -1688,7 +1688,7 @@ consteval bool invalid_subtraction(Ts... ts)
   return !requires { (... - ts); };
 }
 
-inline constexpr struct zero_Bq final : absolute_point_origin<kind_of<isq::activity>> {
+constexpr struct zero_Bq final : absolute_point_origin<kind_of<isq::activity>> {
 } zero_Bq;
 
 static_assert(invalid_addition(zero_Bq + 5 * isq::activity[Bq], 5 * isq::frequency[Hz]));
diff --git a/test/static/quantity_spec_test.cpp b/test/static/quantity_spec_test.cpp
index ee4e86a8..8b5dc990 100644
--- a/test/static/quantity_spec_test.cpp
+++ b/test/static/quantity_spec_test.cpp
@@ -37,22 +37,22 @@ using dimensionless_ = struct dimensionless;
 using dim_one_ = struct dimension_one;
 
 // clang-format off
-inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
-inline constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
-inline constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
+constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
+constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
+constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
 
 // quantities specification
 QUANTITY_SPEC_(length, dim_length);
 QUANTITY_SPEC_(mass, dim_mass);
 QUANTITY_SPEC_(time, dim_time);
 
-inline constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
+constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
 
 QUANTITY_SPEC_(height, length);
 QUANTITY_SPEC_(width, length);
 QUANTITY_SPEC_(radius, width);
 QUANTITY_SPEC_(path_length, length);
-inline constexpr auto arc_length = path_length;
+constexpr auto arc_length = path_length;
 QUANTITY_SPEC_(distance, path_length);
 QUANTITY_SPEC_(position_vector, length, quantity_character::vector);
 QUANTITY_SPEC_(period_duration, time);
diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index d8ddfe60..63658896 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -41,7 +41,7 @@ import std;
 #endif
 
 template<>
-inline constexpr bool mp_units::is_vector<int> = true;
+constexpr bool mp_units::is_vector<int> = true;
 
 namespace {
 
@@ -901,7 +901,7 @@ static_assert(1 * si::si2019::speed_of_light_in_vacuum == 299'792'458 * isq::spe
 
 // Different named dimensions
 template<Reference auto R1, Reference auto R2>
-inline constexpr bool invalid_comparison = !requires { 2 * R1 == 2 * R2; } && !requires { 2 * R2 == 2 * R1; };
+constexpr bool invalid_comparison = !requires { 2 * R1 == 2 * R2; } && !requires { 2 * R2 == 2 * R1; };
 static_assert(invalid_comparison<isq::activity[Bq], isq::frequency[Hz]>);
 
 
diff --git a/test/static/reference_test.cpp b/test/static/reference_test.cpp
index 65abe0bb..603f08e8 100644
--- a/test/static/reference_test.cpp
+++ b/test/static/reference_test.cpp
@@ -39,9 +39,9 @@ using one_ = struct one;
 
 // base dimensions
 // clang-format off
-inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
-inline constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
-inline constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
+constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
+constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
+constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
 
 // quantities specification
 QUANTITY_SPEC_(length, dim_length);
@@ -64,37 +64,37 @@ QUANTITY_SPEC_(power, force* speed);
 QUANTITY_SPEC_(storage_capacity, dimensionless, is_kind);
 
 // base units
-inline constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
-inline constexpr struct metre_ final : named_unit<"m", kind_of<length>> {} metre;
-inline constexpr struct gram_ final : named_unit<"g", kind_of<mass>> {} gram;
-inline constexpr auto kilogram = si::kilo<gram>;
+constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
+constexpr struct metre_ final : named_unit<"m", kind_of<length>> {} metre;
+constexpr struct gram_ final : named_unit<"g", kind_of<mass>> {} gram;
+constexpr auto kilogram = si::kilo<gram>;
 
 namespace nu {
 // hypothetical natural system of units for c=1
 
-inline constexpr struct second_ final : named_unit<"s"> {} second;
-inline constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
+constexpr struct second_ final : named_unit<"s"> {} second;
+constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
 
-inline constexpr struct time : system_reference<time_{}, second> {} time;
-inline constexpr struct length : system_reference<length_{}, second> {} length;
-inline constexpr struct speed : system_reference<speed_{}, second / second> {} speed;
+constexpr struct time : system_reference<time_{}, second> {} time;
+constexpr struct length : system_reference<length_{}, second> {} length;
+constexpr struct speed : system_reference<speed_{}, second / second> {} speed;
 
 }
 
 // derived named units
-inline constexpr struct radian_ final : named_unit<"rad", metre / metre, kind_of<angular_measure>> {} radian;
-inline constexpr struct steradian_ final : named_unit<"sr", square(metre) / square(metre), kind_of<solid_angular_measure>> {} steradian;
-inline constexpr struct hertz_ final : named_unit<"Hz", inverse(second), kind_of<frequency>> {} hertz;
-inline constexpr struct becquerel_ final : named_unit<"Bq", inverse(second), kind_of<activity>> {} becquerel;
-inline constexpr struct newton_ final : named_unit<"N", kilogram * metre / square(second)> {} newton;
-inline constexpr struct joule_ final : named_unit<"J", newton * metre> {} joule;
-inline constexpr struct watt_ final : named_unit<"W", joule / second> {} watt;
+constexpr struct radian_ final : named_unit<"rad", metre / metre, kind_of<angular_measure>> {} radian;
+constexpr struct steradian_ final : named_unit<"sr", square(metre) / square(metre), kind_of<solid_angular_measure>> {} steradian;
+constexpr struct hertz_ final : named_unit<"Hz", inverse(second), kind_of<frequency>> {} hertz;
+constexpr struct becquerel_ final : named_unit<"Bq", inverse(second), kind_of<activity>> {} becquerel;
+constexpr struct newton_ final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+constexpr struct joule_ final : named_unit<"J", newton * metre> {} joule;
+constexpr struct watt_ final : named_unit<"W", joule / second> {} watt;
 
-inline constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
-inline constexpr struct hour_ final : named_unit<"h", mag<60> * minute> {} hour;
-inline constexpr auto kilometre = si::kilo<metre>;
+constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
+constexpr struct hour_ final : named_unit<"h", mag<60> * minute> {} hour;
+constexpr auto kilometre = si::kilo<metre>;
 
-inline constexpr struct bit_ final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
+constexpr struct bit_ final : named_unit<"bit", one, kind_of<storage_capacity>> {} bit;
 // clang-format on
 
 
diff --git a/test/static/test_tools.h b/test/static/test_tools.h
index 88dfc6cb..35a7b45e 100644
--- a/test/static/test_tools.h
+++ b/test/static/test_tools.h
@@ -31,19 +31,19 @@ import std;
 #endif
 
 template<auto V, typename T>
-inline constexpr bool is_of_type = std::is_same_v<MP_UNITS_REMOVE_CONST(decltype(V)), T>;
+constexpr bool is_of_type = std::is_same_v<MP_UNITS_REMOVE_CONST(decltype(V)), T>;
 
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 #if MP_UNITS_API_NO_CRTP
 
-#define QUANTITY_SPEC_(name, ...)                                      \
-  inline constexpr struct name##_ final : quantity_spec<__VA_ARGS__> { \
+#define QUANTITY_SPEC_(name, ...)                               \
+  constexpr struct name##_ final : quantity_spec<__VA_ARGS__> { \
   } name
 
 #else
 
-#define QUANTITY_SPEC_(name, ...)                                               \
-  inline constexpr struct name##_ final : quantity_spec<name##_, __VA_ARGS__> { \
+#define QUANTITY_SPEC_(name, ...)                                        \
+  constexpr struct name##_ final : quantity_spec<name##_, __VA_ARGS__> { \
   } name
 
 #endif
diff --git a/test/static/unit_test.cpp b/test/static/unit_test.cpp
index ba7ecb4c..411b6052 100644
--- a/test/static/unit_test.cpp
+++ b/test/static/unit_test.cpp
@@ -40,10 +40,10 @@ using percent_ = struct percent;
 
 // base dimensions
 // clang-format off
-inline constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
-inline constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
-inline constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
-inline constexpr struct dim_thermodynamic_temperature_ final : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
+constexpr struct dim_length_ final : base_dimension<"L"> {} dim_length;
+constexpr struct dim_mass_ final : base_dimension<"M"> {} dim_mass;
+constexpr struct dim_time_ final : base_dimension<"T"> {} dim_time;
+constexpr struct dim_thermodynamic_temperature_ final : base_dimension<symbol_text{u8"Θ", "O"}> {} dim_thermodynamic_temperature;
 
 // quantities specification
 QUANTITY_SPEC_(length, dim_length);
@@ -52,39 +52,39 @@ QUANTITY_SPEC_(time, dim_time);
 QUANTITY_SPEC_(thermodynamic_temperature, dim_thermodynamic_temperature);
 
 // base units
-inline constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
-inline constexpr struct metre_ final : named_unit<"m", kind_of<length>> {} metre;
-inline constexpr struct gram_ final : named_unit<"g", kind_of<mass>> {} gram;
-inline constexpr auto kilogram = si::kilo<gram>;
-inline constexpr struct kelvin_ final : named_unit<"K", kind_of<thermodynamic_temperature>> {} kelvin;
+constexpr struct second_ final : named_unit<"s", kind_of<time>> {} second;
+constexpr struct metre_ final : named_unit<"m", kind_of<length>> {} metre;
+constexpr struct gram_ final : named_unit<"g", kind_of<mass>> {} gram;
+constexpr auto kilogram = si::kilo<gram>;
+constexpr struct kelvin_ final : named_unit<"K", kind_of<thermodynamic_temperature>> {} kelvin;
 
 // hypothetical natural units for c=1
-inline constexpr struct nu_second_ final : named_unit<"s"> {} nu_second;
+constexpr struct nu_second_ final : named_unit<"s"> {} nu_second;
 
 // derived named units
-inline constexpr struct radian_ final : named_unit<"rad", metre / metre> {} radian;
-inline constexpr struct steradian_ final : named_unit<"sr", square(metre) / square(metre)> {} steradian;
-inline constexpr struct hertz_ final : named_unit<"Hz", inverse(second)> {} hertz;
-inline constexpr struct becquerel_ final : named_unit<"Bq", inverse(second)> {} becquerel;
-inline constexpr struct newton_ final : named_unit<"N", kilogram * metre / square(second)> {} newton;
-inline constexpr struct pascal_ final : named_unit<"Pa", newton / square(metre)> {} pascal;
-inline constexpr struct joule_ final : named_unit<"J", newton * metre> {} joule;
-inline constexpr struct watt_ final : named_unit<"W", joule / second> {} watt;
-inline constexpr struct degree_Celsius_ final : named_unit<symbol_text{u8"℃", "`C"}, kelvin> {} degree_Celsius;
+constexpr struct radian_ final : named_unit<"rad", metre / metre> {} radian;
+constexpr struct steradian_ final : named_unit<"sr", square(metre) / square(metre)> {} steradian;
+constexpr struct hertz_ final : named_unit<"Hz", inverse(second)> {} hertz;
+constexpr struct becquerel_ final : named_unit<"Bq", inverse(second)> {} becquerel;
+constexpr struct newton_ final : named_unit<"N", kilogram * metre / square(second)> {} newton;
+constexpr struct pascal_ final : named_unit<"Pa", newton / square(metre)> {} pascal;
+constexpr struct joule_ final : named_unit<"J", newton * metre> {} joule;
+constexpr struct watt_ final : named_unit<"W", joule / second> {} watt;
+constexpr struct degree_Celsius_ final : named_unit<symbol_text{u8"℃", "`C"}, kelvin> {} degree_Celsius;
 
-inline constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
-inline constexpr struct hour_ final : named_unit<"h", mag<60> * minute> {} hour;
-inline constexpr struct degree_ final : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * radian> {} degree;
+constexpr struct minute_ final : named_unit<"min", mag<60> * second> {} minute;
+constexpr struct hour_ final : named_unit<"h", mag<60> * minute> {} hour;
+constexpr struct degree_ final : named_unit<symbol_text{u8"°", "deg"}, mag_pi / mag<180> * radian> {} degree;
 
-inline constexpr struct yard_ final : named_unit<"yd", mag_ratio<9'144, 10'000> * metre> {} yard;
-inline constexpr struct mile_ final : named_unit<"mi", mag<1760> * yard> {} mile;
+constexpr struct yard_ final : named_unit<"yd", mag_ratio<9'144, 10'000> * metre> {} yard;
+constexpr struct mile_ final : named_unit<"mi", mag<1760> * yard> {} mile;
 
-inline constexpr auto kilometre = si::kilo<metre>;
-inline constexpr auto kilojoule = si::kilo<joule>;
+constexpr auto kilometre = si::kilo<metre>;
+constexpr auto kilojoule = si::kilo<joule>;
 
 // physical constant units
-inline constexpr struct standard_gravity_ final : named_unit<symbol_text{u8"g₀", "g_0"}, mag_ratio<980'665, 100'000> * metre / square(second)> {} standard_gravity;
-inline constexpr struct speed_of_light_in_vacuum_ final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
+constexpr struct standard_gravity_ final : named_unit<symbol_text{u8"g₀", "g_0"}, mag_ratio<980'665, 100'000> * metre / square(second)> {} standard_gravity;
+constexpr struct speed_of_light_in_vacuum_ final : named_unit<"c", mag<299'792'458> * metre / second> {} speed_of_light_in_vacuum;
 
 // clang-format on