diff --git a/example/kalman_filter/kalman_filter-example_6.cpp b/example/kalman_filter/kalman_filter-example_6.cpp
index 2dc55ba1..d70b974a 100644
--- a/example/kalman_filter/kalman_filter-example_6.cpp
+++ b/example/kalman_filter/kalman_filter-example_6.cpp
@@ -62,12 +62,14 @@ int main()
   using estimate = kalman::system_state_estimate<qp>;
   using state = estimate::state_type;
 
-  const quantity process_noise_variance = 0.0001 * pow<2>(deg_C);
-  const estimate initial{state{qp{60. * deg_C}}, 100. * deg_C};
-  const std::array measurements = {qp{49.986 * deg_C}, qp{49.963 * deg_C}, qp{50.097 * deg_C}, qp{50.001 * deg_C},
-                                   qp{50.018 * deg_C}, qp{50.05 * deg_C},  qp{49.938 * deg_C}, qp{49.858 * deg_C},
-                                   qp{49.965 * deg_C}, qp{50.114 * deg_C}};
-  const quantity measurement_error = 0.1 * deg_C;
+  const quantity process_noise_variance = 0.0001 * relative(pow<2>(deg_C));
+  const estimate initial{state{qp{60. * relative(deg_C)}}, 100. * relative(deg_C)};
+  const std::array measurements = {qp{49.986 * relative(deg_C)}, qp{49.963 * relative(deg_C)},
+                                   qp{50.097 * relative(deg_C)}, qp{50.001 * relative(deg_C)},
+                                   qp{50.018 * relative(deg_C)}, qp{50.05 * relative(deg_C)},
+                                   qp{49.938 * relative(deg_C)}, qp{49.858 * relative(deg_C)},
+                                   qp{49.965 * relative(deg_C)}, qp{50.114 * relative(deg_C)}};
+  const quantity measurement_error = 0.1 * relative(deg_C);
   const quantity measurement_variance = pow<2>(measurement_error);
 
   auto predict = [=](const estimate& current) {
diff --git a/example/kalman_filter/kalman_filter-example_7.cpp b/example/kalman_filter/kalman_filter-example_7.cpp
index 62ce652b..104d08f6 100644
--- a/example/kalman_filter/kalman_filter-example_7.cpp
+++ b/example/kalman_filter/kalman_filter-example_7.cpp
@@ -62,12 +62,14 @@ int main()
   using estimate = kalman::system_state_estimate<qp>;
   using state = estimate::state_type;
 
-  const quantity process_noise_variance = 0.0001 * pow<2>(deg_C);
-  const estimate initial{state{qp{10. * deg_C}}, 100. * deg_C};
-  const std::array measurements = {qp{50.486 * deg_C}, qp{50.963 * deg_C}, qp{51.597 * deg_C}, qp{52.001 * deg_C},
-                                   qp{52.518 * deg_C}, qp{53.05 * deg_C},  qp{53.438 * deg_C}, qp{53.858 * deg_C},
-                                   qp{54.465 * deg_C}, qp{55.114 * deg_C}};
-  const quantity measurement_error = 0.1 * deg_C;
+  const quantity process_noise_variance = 0.0001 * relative(pow<2>(deg_C));
+  const estimate initial{state{qp{10. * relative(deg_C)}}, 100. * relative(deg_C)};
+  const std::array measurements = {qp{50.486 * relative(deg_C)}, qp{50.963 * relative(deg_C)},
+                                   qp{51.597 * relative(deg_C)}, qp{52.001 * relative(deg_C)},
+                                   qp{52.518 * relative(deg_C)}, qp{53.05 * relative(deg_C)},
+                                   qp{53.438 * relative(deg_C)}, qp{53.858 * relative(deg_C)},
+                                   qp{54.465 * relative(deg_C)}, qp{55.114 * relative(deg_C)}};
+  const quantity measurement_error = 0.1 * relative(deg_C);
   const quantity measurement_variance = pow<2>(measurement_error);
 
   auto predict = [=](const estimate& current) {
diff --git a/example/kalman_filter/kalman_filter-example_8.cpp b/example/kalman_filter/kalman_filter-example_8.cpp
index 760212ec..d818140e 100644
--- a/example/kalman_filter/kalman_filter-example_8.cpp
+++ b/example/kalman_filter/kalman_filter-example_8.cpp
@@ -62,12 +62,14 @@ int main()
   using estimate = kalman::system_state_estimate<qp>;
   using state = estimate::state_type;
 
-  const quantity process_noise_variance = 0.15 * pow<2>(deg_C);
-  const estimate initial{state{qp{10. * deg_C}}, 100. * deg_C};
-  const std::array measurements = {qp{50.486 * deg_C}, qp{50.963 * deg_C}, qp{51.597 * deg_C}, qp{52.001 * deg_C},
-                                   qp{52.518 * deg_C}, qp{53.05 * deg_C},  qp{53.438 * deg_C}, qp{53.858 * deg_C},
-                                   qp{54.465 * deg_C}, qp{55.114 * deg_C}};
-  const quantity measurement_error = 0.1 * deg_C;
+  const quantity process_noise_variance = 0.15 * relative(pow<2>(deg_C));
+  const estimate initial{state{qp{10. * relative(deg_C)}}, 100. * relative(deg_C)};
+  const std::array measurements = {qp{50.486 * relative(deg_C)}, qp{50.963 * relative(deg_C)},
+                                   qp{51.597 * relative(deg_C)}, qp{52.001 * relative(deg_C)},
+                                   qp{52.518 * relative(deg_C)}, qp{53.05 * relative(deg_C)},
+                                   qp{53.438 * relative(deg_C)}, qp{53.858 * relative(deg_C)},
+                                   qp{54.465 * relative(deg_C)}, qp{55.114 * relative(deg_C)}};
+  const quantity measurement_error = 0.1 * relative(deg_C);
   const quantity measurement_variance = pow<2>(measurement_error);
 
   auto predict = [=](const estimate& current) {
diff --git a/example/spectroscopy_units.cpp b/example/spectroscopy_units.cpp
index e64eee8f..85fe8344 100644
--- a/example/spectroscopy_units.cpp
+++ b/example/spectroscopy_units.cpp
@@ -84,7 +84,7 @@ int main()
   const auto t3 = std::make_tuple(isq::energy(q3 * h), isq::wavenumber(q3 / c), q3,
                                   isq::thermodynamic_temperature(q3 * h / kb), isq::wavelength(c / q3));
 
-  const auto q4 = isq::thermodynamic_temperature(1. * K);
+  const auto q4 = isq::thermodynamic_temperature(1. * relative(K));
   const auto t4 = std::make_tuple(isq::energy(q4 * kb), isq::wavenumber(q4 * kb / (h * c)), isq::frequency(q4 * kb / h),
                                   q4, isq::wavelength(h * c / (q4 * kb)));
 
diff --git a/src/core/include/mp-units/bits/sudo_cast.h b/src/core/include/mp-units/bits/sudo_cast.h
index 0444f93e..768a5dc5 100644
--- a/src/core/include/mp-units/bits/sudo_cast.h
+++ b/src/core/include/mp-units/bits/sudo_cast.h
@@ -97,10 +97,10 @@ template<Quantity To, typename From>
   if constexpr (q_unit == To::unit) {
     // no scaling of the number needed
     return {static_cast<MP_UNITS_TYPENAME To::rep>(std::forward<From>(q).numerical_value_is_an_implementation_detail_),
-            To::reference};  // this is the only (and recommended) way to do
-                             // a truncating conversion on a number, so we are
-                             // using static_cast to suppress all the compiler
-                             // warnings on conversions
+            relative(To::reference)};  // this is the only (and recommended) way to do
+                                       // a truncating conversion on a number, so we are
+                                       // using static_cast to suppress all the compiler
+                                       // warnings on conversions
   } else {
     // scale the number
     using traits = magnitude_conversion_traits<To, std::remove_reference_t<From>>;
@@ -108,13 +108,13 @@ template<Quantity To, typename From>
       // this results in great assembly
       auto res = static_cast<MP_UNITS_TYPENAME To::rep>(
         static_cast<traits::c_type>(q.numerical_value_is_an_implementation_detail_) * traits::ratio);
-      return {res, To::reference};
+      return {res, relative(To::reference)};
     } else {
       // this is slower but allows conversions like 2000 m -> 2 km without loosing data
       auto res = static_cast<MP_UNITS_TYPENAME To::rep>(
         static_cast<traits::c_type>(q.numerical_value_is_an_implementation_detail_) * traits::num_mult /
         traits::den_mult * traits::irr_mult);
-      return {res, To::reference};
+      return {res, relative(To::reference)};
     }
   }
 }
@@ -175,5 +175,4 @@ template<QuantityPoint ToQP, typename FromQP>
   }
 }
 
-
 }  // namespace mp_units::detail
diff --git a/src/core/include/mp-units/framework/quantity.h b/src/core/include/mp-units/framework/quantity.h
index 587ab2a2..44dd8742 100644
--- a/src/core/include/mp-units/framework/quantity.h
+++ b/src/core/include/mp-units/framework/quantity.h
@@ -88,6 +88,12 @@ template<typename Func, Quantity Q1, Quantity Q2>
 using common_quantity_for = quantity<common_reference(Q1::reference, Q2::reference),
                                      std::invoke_result_t<Func, typename Q1::rep, typename Q2::rep>>;
 
+template<typename T, typename R>
+concept SameOriginalReferenceAs = RelativeReference<T> && Reference<R> && (get_original_reference(T{}) == R{});
+
+template<typename R1, typename R2, typename Rep1, typename Rep2>
+concept SameValueAs = detail::SameOriginalReferenceAs<R1, R2> && std::same_as<Rep1, Rep2>;
+
 }  // namespace detail
 
 MP_UNITS_EXPORT_BEGIN
@@ -117,25 +123,25 @@ public:
   [[nodiscard]] static constexpr quantity zero() noexcept
     requires requires { quantity_values<rep>::zero(); }
   {
-    return {quantity_values<rep>::zero(), R};
+    return {quantity_values<rep>::zero(), relative(R)};
   }
 
   [[nodiscard]] static constexpr quantity one() noexcept
     requires requires { quantity_values<rep>::one(); }
   {
-    return {quantity_values<rep>::one(), R};
+    return {quantity_values<rep>::one(), relative(R)};
   }
 
   [[nodiscard]] static constexpr quantity min() noexcept
     requires requires { quantity_values<rep>::min(); }
   {
-    return {quantity_values<rep>::min(), R};
+    return {quantity_values<rep>::min(), relative(R)};
   }
 
   [[nodiscard]] static constexpr quantity max() noexcept
     requires requires { quantity_values<rep>::max(); }
   {
-    return {quantity_values<rep>::max(), R};
+    return {quantity_values<rep>::max(), relative(R)};
   }
 
   // construction, assignment, destruction
@@ -144,15 +150,17 @@ public:
   quantity(quantity&&) = default;
   ~quantity() = default;
 
-  template<typename Value>
-    requires std::same_as<std::remove_cvref_t<Value>, Rep>
-  constexpr quantity(Value&& v, decltype(R)) : numerical_value_is_an_implementation_detail_(std::forward<Value>(v))
+  template<typename Value, RelativeReference R2>
+    requires detail::SameValueAs<R2, decltype(R), std::remove_cvref_t<Value>, Rep>
+  constexpr quantity(Value&& v, R2) : numerical_value_is_an_implementation_detail_(std::forward<Value>(v))
   {
   }
 
-  template<typename Value, Reference R2>
-    requires detail::QuantityConvertibleTo<quantity<R2{}, std::remove_cvref_t<Value>>, quantity>
-  constexpr quantity(Value&& v, R2) : quantity(quantity<R2{}, std::remove_cvref_t<Value>>{std::forward<Value>(v), R2{}})
+  template<typename Value, RelativeReference R2>
+    requires(!detail::SameValueAs<R2, decltype(R), std::remove_cvref_t<Value>, Rep>) &&
+            detail::QuantityConvertibleTo<quantity<R2{}, std::remove_cvref_t<Value>>, quantity>
+  constexpr quantity(Value&& v, R2) :
+      quantity(quantity<detail::get_original_reference(R2{}), std::remove_cvref_t<Value>>{std::forward<Value>(v), R2{}})
   {
   }
 
@@ -172,7 +180,7 @@ public:
                      // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
                      !std::convertible_to<typename quantity_like_traits<Q>::rep, Rep>) quantity(const Q& q) :
       quantity(
-        ::mp_units::quantity{quantity_like_traits<Q>::to_numerical_value(q).value, quantity_like_traits<Q>::reference})
+        ::mp_units::quantity{quantity_like_traits<Q>::to_numerical_value(q).value, relative(quantity_like_traits<Q>::reference)})
   {
   }
 
@@ -266,7 +274,7 @@ public:
       } -> std::common_with<rep>;
     }
   {
-    return ::mp_units::quantity{+numerical_value_is_an_implementation_detail_, reference};
+    return ::mp_units::quantity{+numerical_value_is_an_implementation_detail_, relative(reference)};
   }
 
   [[nodiscard]] constexpr QuantityOf<quantity_spec> auto operator-() const
@@ -276,7 +284,7 @@ public:
       } -> std::common_with<rep>;
     }
   {
-    return ::mp_units::quantity{-numerical_value_is_an_implementation_detail_, reference};
+    return ::mp_units::quantity{-numerical_value_is_an_implementation_detail_, relative(reference)};
   }
 
   template<typename Q>
@@ -298,7 +306,7 @@ public:
       } -> std::common_with<rep>;
     }
   {
-    return ::mp_units::quantity{numerical_value_is_an_implementation_detail_++, reference};
+    return ::mp_units::quantity{numerical_value_is_an_implementation_detail_++, relative(reference)};
   }
 
   template<typename Q>
@@ -320,7 +328,7 @@ public:
       } -> std::common_with<rep>;
     }
   {
-    return ::mp_units::quantity{numerical_value_is_an_implementation_detail_--, reference};
+    return ::mp_units::quantity{numerical_value_is_an_implementation_detail_--, relative(reference)};
   }
 
   // compound assignment operators
@@ -419,9 +427,9 @@ public:
 };
 
 // CTAD
-template<typename Value, Reference R>
-  requires RepresentationOf<Value, get_quantity_spec(R{}).character>
-quantity(Value v, R) -> quantity<R{}, Value>;
+template<typename Value, RelativeReference R>
+  requires RepresentationOf<Value, get_quantity_spec(detail::get_original_reference(R{})).character>
+quantity(Value v, R) -> quantity<detail::get_original_reference(R{}), Value>;
 
 template<QuantityLike Q>
 explicit(
@@ -437,7 +445,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   const ret ret_lhs(lhs);
   const ret ret_rhs(rhs);
   return quantity{ret_lhs.numerical_value_ref_in(ret::unit) + ret_rhs.numerical_value_ref_in(ret::unit),
-                  ret::reference};
+                  relative(ret::reference)};
 }
 
 template<auto R1, typename Rep1, auto R2, typename Rep2>
@@ -448,7 +456,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   const ret ret_lhs(lhs);
   const ret ret_rhs(rhs);
   return quantity{ret_lhs.numerical_value_ref_in(ret::unit) - ret_rhs.numerical_value_ref_in(ret::unit),
-                  ret::reference};
+                  relative(ret::reference)};
 }
 
 template<auto R1, typename Rep1, auto R2, typename Rep2>
@@ -461,14 +469,15 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   const ret ret_lhs(lhs);
   const ret ret_rhs(rhs);
   return quantity{ret_lhs.numerical_value_ref_in(ret::unit) % ret_rhs.numerical_value_ref_in(ret::unit),
-                  ret::reference};
+                  relative(ret::reference)};
 }
 
 template<auto R1, typename Rep1, auto R2, typename Rep2>
   requires detail::InvocableQuantities<std::multiplies<>, quantity<R1, Rep1>, quantity<R2, Rep2>>
 [[nodiscard]] constexpr Quantity auto operator*(const quantity<R1, Rep1>& lhs, const quantity<R2, Rep2>& rhs)
 {
-  return quantity{lhs.numerical_value_ref_in(get_unit(R1)) * rhs.numerical_value_ref_in(get_unit(R2)), R1 * R2};
+  return quantity{lhs.numerical_value_ref_in(get_unit(R1)) * rhs.numerical_value_ref_in(get_unit(R2)),
+                  relative(R1 * R2)};
 }
 
 template<auto R, typename Rep, typename Value>
@@ -476,7 +485,7 @@ template<auto R, typename Rep, typename Value>
           detail::InvokeResultOf<get_quantity_spec(R).character, std::multiplies<>, Rep, const Value&>
 [[nodiscard]] constexpr QuantityOf<get_quantity_spec(R)> auto operator*(const quantity<R, Rep>& q, const Value& v)
 {
-  return quantity{q.numerical_value_ref_in(get_unit(R)) * v, R};
+  return quantity{q.numerical_value_ref_in(get_unit(R)) * v, relative(R)};
 }
 
 template<typename Value, auto R, typename Rep>
@@ -484,7 +493,7 @@ template<typename Value, auto R, typename Rep>
           detail::InvokeResultOf<get_quantity_spec(R).character, std::multiplies<>, const Value&, Rep>
 [[nodiscard]] constexpr QuantityOf<get_quantity_spec(R)> auto operator*(const Value& v, const quantity<R, Rep>& q)
 {
-  return quantity{v * q.numerical_value_ref_in(get_unit(R)), R};
+  return quantity{v * q.numerical_value_ref_in(get_unit(R)), relative(R)};
 }
 
 template<auto R1, typename Rep1, auto R2, typename Rep2>
@@ -492,7 +501,8 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
 [[nodiscard]] constexpr Quantity auto operator/(const quantity<R1, Rep1>& lhs, const quantity<R2, Rep2>& rhs)
 {
   MP_UNITS_EXPECTS_DEBUG(rhs != rhs.zero());
-  return quantity{lhs.numerical_value_ref_in(get_unit(R1)) / rhs.numerical_value_ref_in(get_unit(R2)), R1 / R2};
+  return quantity{lhs.numerical_value_ref_in(get_unit(R1)) / rhs.numerical_value_ref_in(get_unit(R2)),
+                  relative(R1 / R2)};
 }
 
 template<auto R, typename Rep, typename Value>
@@ -501,7 +511,7 @@ template<auto R, typename Rep, typename Value>
 [[nodiscard]] constexpr QuantityOf<get_quantity_spec(R)> auto operator/(const quantity<R, Rep>& q, const Value& v)
 {
   MP_UNITS_EXPECTS_DEBUG(v != quantity_values<Value>::zero());
-  return quantity{q.numerical_value_ref_in(get_unit(R)) / v, R};
+  return quantity{q.numerical_value_ref_in(get_unit(R)) / v, relative(R)};
 }
 
 template<typename Value, auto R, typename Rep>
@@ -510,7 +520,7 @@ template<typename Value, auto R, typename Rep>
 [[nodiscard]] constexpr QuantityOf<inverse(get_quantity_spec(R))> auto operator/(const Value& v,
                                                                                  const quantity<R, Rep>& q)
 {
-  return quantity{v / q.numerical_value_ref_in(get_unit(R)), ::mp_units::one / R};
+  return quantity{v / q.numerical_value_ref_in(get_unit(R)), relative(::mp_units::one / R)};
 }
 
 template<auto R1, typename Rep1, auto R2, typename Rep2>
diff --git a/src/core/include/mp-units/framework/quantity_cast.h b/src/core/include/mp-units/framework/quantity_cast.h
index 53b14815..a915325a 100644
--- a/src/core/include/mp-units/framework/quantity_cast.h
+++ b/src/core/include/mp-units/framework/quantity_cast.h
@@ -57,7 +57,7 @@ template<QuantitySpec auto ToQS, typename Q>
 [[nodiscard]] constexpr Quantity auto quantity_cast(Q&& q)
 {
   return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                  make_reference(ToQS, std::remove_reference_t<Q>::unit)};
+                  relative(make_reference(ToQS, std::remove_reference_t<Q>::unit))};
 }
 
 /**
diff --git a/src/core/include/mp-units/framework/quantity_spec.h b/src/core/include/mp-units/framework/quantity_spec.h
index 855dd25c..3979f3e5 100644
--- a/src/core/include/mp-units/framework/quantity_spec.h
+++ b/src/core/include/mp-units/framework/quantity_spec.h
@@ -129,7 +129,7 @@ struct quantity_spec_interface {
              (explicitly_convertible(std::remove_reference_t<Q>::quantity_spec, self))
   {
     return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                    detail::make_reference(self, std::remove_cvref_t<Q>::unit)};
+                    relative(detail::make_reference(self, std::remove_cvref_t<Q>::unit))};
   }
 #else
   template<typename Self_ = Self, UnitOf<Self_{}> U>
@@ -144,7 +144,7 @@ struct quantity_spec_interface {
   [[nodiscard]] constexpr Quantity auto operator()(Q&& q) const
   {
     return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                    detail::make_reference(Self{}, std::remove_cvref_t<Q>::unit)};
+                    relative(detail::make_reference(Self{}, std::remove_cvref_t<Q>::unit))};
   }
 #endif
 };
@@ -341,7 +341,7 @@ struct quantity_spec<Self, QS, Args...> : detail::propagate_equation<QS>, detail
   [[nodiscard]] constexpr Quantity auto operator()(Q&& q) const
   {
     return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                    detail::make_reference(Self{}, std::remove_cvref_t<Q>::unit)};
+                    relative(detail::make_reference(Self{}, std::remove_cvref_t<Q>::unit))};
   }
 #endif
 };
diff --git a/src/core/include/mp-units/framework/reference.h b/src/core/include/mp-units/framework/reference.h
index 746abb44..9cb269ac 100644
--- a/src/core/include/mp-units/framework/reference.h
+++ b/src/core/include/mp-units/framework/reference.h
@@ -40,8 +40,18 @@ namespace detail {
 template<QuantitySpec auto Q, Unit auto U>
 using reference_t = reference<MP_UNITS_REMOVE_CONST(decltype(Q)), MP_UNITS_REMOVE_CONST(decltype(U))>;
 
+template<typename R>
+  requires RelativeReference<R> || AbsoluteReference<R>
+[[nodiscard]] consteval Reference auto get_original_reference(R r)
+{
+  if constexpr (requires { typename R::_type_; })
+    return typename R::_type_{};
+  else
+    return r;
 }
 
+}  // namespace detail
+
 MP_UNITS_EXPORT_BEGIN
 
 [[nodiscard]] consteval QuantitySpec auto get_quantity_spec(AssociatedUnit auto u)
@@ -173,18 +183,19 @@ struct reference {
 };
 
 
-template<typename Rep, Reference R>
-  requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
-[[nodiscard]] constexpr quantity<R{}, std::remove_cvref_t<Rep>> operator*(Rep&& lhs, R)
+template<typename Rep, RelativeReference R>
+  requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(detail::get_original_reference(R{})).character>
+[[nodiscard]] constexpr quantity<detail::get_original_reference(R{}), std::remove_cvref_t<Rep>> operator*(Rep&& lhs, R)
 {
   return quantity{std::forward<Rep>(lhs), R{}};
 }
 
-template<typename Rep, Reference R>
-  requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(R{}).character>
-[[nodiscard]] constexpr quantity<inverse(R{}), std::remove_cvref_t<Rep>> operator/(Rep&& lhs, R)
+template<typename Rep, RelativeReference R>
+  requires RepresentationOf<std::remove_cvref_t<Rep>, get_quantity_spec(detail::get_original_reference(R{})).character>
+[[nodiscard]] constexpr quantity<inverse(detail::get_original_reference(R{})), std::remove_cvref_t<Rep>> operator/(
+  Rep&& lhs, R)
 {
-  return quantity{std::forward<Rep>(lhs), inverse(R{})};
+  return quantity{std::forward<Rep>(lhs), relative(inverse(detail::get_original_reference(R{})))};
 }
 
 template<Reference R, typename Rep>
@@ -202,7 +213,7 @@ template<typename Q, Reference R>
 [[nodiscard]] constexpr Quantity auto operator*(Q&& q, R)
 {
   return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                  std::remove_cvref_t<Q>::reference * R{}};
+                  relative(std::remove_cvref_t<Q>::reference * R{})};
 }
 
 template<typename Q, Reference R>
@@ -210,7 +221,7 @@ template<typename Q, Reference R>
 [[nodiscard]] constexpr Quantity auto operator/(Q&& q, R)
 {
   return quantity{std::forward<Q>(q).numerical_value_is_an_implementation_detail_,
-                  std::remove_cvref_t<Q>::reference / R{}};
+                  relative(std::remove_cvref_t<Q>::reference / R{})};
 }
 
 template<Reference R, typename Q>
diff --git a/src/core/include/mp-units/framework/reference_concepts.h b/src/core/include/mp-units/framework/reference_concepts.h
index a2c78365..857dbd0b 100644
--- a/src/core/include/mp-units/framework/reference_concepts.h
+++ b/src/core/include/mp-units/framework/reference_concepts.h
@@ -80,4 +80,33 @@ concept ReferenceOf = Reference<T> && QuantitySpecOf<decltype(get_quantity_spec(
 
 MP_UNITS_EXPORT_END
 
+template<Reference R>
+struct relative_ final {
+  using _type_ = R;
+};
+
+template<Reference R>
+struct absolute_ final {
+  using _type_ = R;
+};
+
+template<Reference R>
+MP_UNITS_EXPORT [[nodiscard]] consteval relative_<R> relative(R)
+{
+  return {};
+}
+
+template<Reference R>
+MP_UNITS_EXPORT [[nodiscard]] consteval absolute_<R> absolute(R)
+{
+  return {};
+}
+
+template<typename T>
+MP_UNITS_EXPORT concept RelativeReference =
+  (Reference<T> && !requires { get_unit(T{}).point_origin; }) || is_specialization_of<T, relative_>;
+
+template<typename T>
+MP_UNITS_EXPORT concept AbsoluteReference = is_specialization_of<T, absolute_>;
+
 }  // namespace mp_units
diff --git a/src/core/include/mp-units/math.h b/src/core/include/mp-units/math.h
index 50dd222a..b2859dfd 100644
--- a/src/core/include/mp-units/math.h
+++ b/src/core/include/mp-units/math.h
@@ -115,7 +115,7 @@ template<ReferenceOf<dimensionless> auto R, typename Rep>
 {
   using std::exp;
   return value_cast<get_unit(R)>(
-    quantity{static_cast<Rep>(exp(q.force_numerical_value_in(q.unit))), detail::clone_reference_with<one>(R)});
+    quantity{static_cast<Rep>(exp(q.force_numerical_value_in(q.unit))), relative(detail::clone_reference_with<one>(R))});
 }
 
 /**
@@ -236,7 +236,7 @@ template<auto R, auto S, auto T, typename Rep1, typename Rep2, typename Rep3>
   using std::fma;
   return quantity{
     fma(a.numerical_value_ref_in(a.unit), x.numerical_value_ref_in(x.unit), b.numerical_value_ref_in(b.unit)),
-    common_reference(R * S, T)};
+    relative(common_reference(R * S, T))};
 }
 
 /**
@@ -260,7 +260,7 @@ template<auto R, auto S, auto T, auto Origin, typename Rep1, typename Rep2, type
   using std::fma;
   return Origin + quantity{fma(a.numerical_value_ref_in(a.unit), x.numerical_value_ref_in(x.unit),
                                b.quantity_ref_from(b.point_origin).numerical_value_ref_in(b.unit)),
-                           common_reference(R * S, T)};
+                           relative(common_reference(R * S, T))};
 }
 
 /**
@@ -277,7 +277,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   constexpr auto ref = common_reference(R1, R2);
   constexpr auto unit = get_unit(ref);
   using std::fmod;
-  return quantity{fmod(x.numerical_value_in(unit), y.numerical_value_in(unit)), ref};
+  return quantity{fmod(x.numerical_value_in(unit), y.numerical_value_in(unit)), relative(ref)};
 }
 
 /**
@@ -294,7 +294,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   constexpr auto ref = common_reference(R1, R2);
   constexpr auto unit = get_unit(ref);
   using std::remainder;
-  return quantity{remainder(x.numerical_value_in(unit), y.numerical_value_in(unit)), ref};
+  return quantity{remainder(x.numerical_value_in(unit), y.numerical_value_in(unit)), relative(ref)};
 }
 
 
@@ -339,7 +339,7 @@ template<Unit auto To, auto R, typename Rep>
       return {static_cast<Rep>(floor(q.numerical_value_ref_in(q.unit))), detail::clone_reference_with<To>(R)};
     } else {
       return handle_signed_results(
-        quantity{static_cast<Rep>(floor(q.force_numerical_value_in(To))), detail::clone_reference_with<To>(R)});
+        quantity{static_cast<Rep>(floor(q.force_numerical_value_in(To))), relative(detail::clone_reference_with<To>(R))});
     }
   } else {
     if constexpr (To == get_unit(R)) {
@@ -376,7 +376,7 @@ template<Unit auto To, auto R, typename Rep>
       return {static_cast<Rep>(ceil(q.numerical_value_ref_in(q.unit))), detail::clone_reference_with<To>(R)};
     } else {
       return handle_signed_results(
-        quantity{static_cast<Rep>(ceil(q.force_numerical_value_in(To))), detail::clone_reference_with<To>(R)});
+        quantity{static_cast<Rep>(ceil(q.force_numerical_value_in(To))), relative(detail::clone_reference_with<To>(R))});
     }
   } else {
     if constexpr (To == get_unit(R)) {
@@ -456,7 +456,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2>
   constexpr auto ref = common_reference(R1, R2);
   constexpr auto unit = get_unit(ref);
   using std::hypot;
-  return quantity{hypot(x.numerical_value_in(unit), y.numerical_value_in(unit)), ref};
+  return quantity{hypot(x.numerical_value_in(unit), y.numerical_value_in(unit)), relative(ref)};
 }
 
 /**
@@ -474,7 +474,7 @@ template<auto R1, typename Rep1, auto R2, typename Rep2, auto R3, typename Rep3>
   constexpr auto ref = common_reference(R1, R2);
   constexpr auto unit = get_unit(ref);
   using std::hypot;
-  return quantity{hypot(x.numerical_value_in(unit), y.numerical_value_in(unit), z.numerical_value_in(unit)), ref};
+  return quantity{hypot(x.numerical_value_in(unit), y.numerical_value_in(unit), z.numerical_value_in(unit)), relative(ref)};
 }
 
 }  // namespace mp_units
diff --git a/src/systems/include/mp-units/systems/si/units.h b/src/systems/include/mp-units/systems/si/units.h
index bbcf0166..f358083e 100644
--- a/src/systems/include/mp-units/systems/si/units.h
+++ b/src/systems/include/mp-units/systems/si/units.h
@@ -77,7 +77,7 @@ 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;
 
-inline constexpr struct ice_point final : relative_point_origin<quantity_point{273'150 * milli<kelvin>}> {} ice_point;
+inline constexpr struct ice_point final : relative_point_origin<quantity_point{273'150 * relative(milli<kelvin>)}> {} ice_point;
 inline constexpr auto zeroth_degree_Celsius = ice_point;
 inline constexpr struct degree_Celsius final : named_unit<symbol_text{u8"°C", "`C"}, kelvin, zeroth_degree_Celsius> {} degree_Celsius;
 
diff --git a/src/systems/include/mp-units/systems/usc.h b/src/systems/include/mp-units/systems/usc.h
index 3cde7c36..3b1e6bea 100644
--- a/src/systems/include/mp-units/systems/usc.h
+++ b/src/systems/include/mp-units/systems/usc.h
@@ -118,7 +118,7 @@ inline constexpr struct troy_pound final : named_unit<"lb t", mag<12> * troy_onc
 inline constexpr struct inch_of_mercury final : named_unit<"inHg", mag_ratio<3'386'389, 1'000> * si::pascal> {} inch_of_mercury;
 
 // https://en.wikipedia.org/wiki/United_States_customary_units#Temperature
-inline constexpr struct zeroth_degree_Fahrenheit final : relative_point_origin<quantity_point{-32 * (mag_ratio<5, 9> * si::degree_Celsius)}> {} zeroth_degree_Fahrenheit;
+inline constexpr struct zeroth_degree_Fahrenheit final : relative_point_origin<quantity_point{-32 * relative(mag_ratio<5, 9> * si::degree_Celsius)}> {} zeroth_degree_Fahrenheit;
 inline constexpr struct degree_Fahrenheit final : named_unit<symbol_text{u8"°F", "`F"}, mag_ratio<5, 9> * si::degree_Celsius, zeroth_degree_Fahrenheit> {} degree_Fahrenheit;
 
 // clang-format on
diff --git a/test/static/quantity_point_test.cpp b/test/static/quantity_point_test.cpp
index a335ccac..758f81b9 100644
--- a/test/static/quantity_point_test.cpp
+++ b/test/static/quantity_point_test.cpp
@@ -802,8 +802,8 @@ static_assert(
 
 static_assert(quantity_point{42 * m}.quantity_from_zero() == 42 * m);
 static_assert(quantity_point{isq::height(42 * m)}.quantity_from_zero() == 42 * m);
-static_assert(quantity_point{20 * deg_C}.quantity_from_zero() == 20 * deg_C);
-static_assert(quantity_point{20. * deg_C}.in(deg_F).quantity_from_zero() == 68 * deg_F);
+static_assert(quantity_point{20 * relative(deg_C)}.quantity_from_zero() == 20 * relative(deg_C));
+static_assert(quantity_point{20. * relative(deg_C)}.in(deg_F).quantity_from_zero() == 68 * relative(deg_F));
 
 static_assert((mean_sea_level + 42 * m).quantity_from_zero() == 42 * m);
 static_assert((ground_level + 42 * m).quantity_from_zero() == 84 * m);
@@ -889,13 +889,13 @@ static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{isq::he
 static_assert(quantity_point{isq::height(123 * m)}.unit == si::metre);
 static_assert(quantity_point{isq::height(123 * m)}.quantity_spec == isq::height);
 
-static_assert(std::is_same_v<decltype(quantity_point{20 * deg_C})::rep, int>);
-static_assert(
-  std::is_same_v<std::remove_const_t<decltype(quantity_point{20 * deg_C}.point_origin)>, struct si::ice_point>);
-static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{20 * deg_C}.absolute_point_origin)>,
+static_assert(std::is_same_v<decltype(quantity_point{20 * relative(deg_C)})::rep, int>);
+static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{20 * relative(deg_C)}.point_origin)>,
+                             struct si::ice_point>);
+static_assert(std::is_same_v<std::remove_const_t<decltype(quantity_point{20 * relative(deg_C)}.absolute_point_origin)>,
                              struct si::absolute_zero>);
-static_assert(quantity_point{20 * deg_C}.unit == si::degree_Celsius);
-static_assert(quantity_point{20 * deg_C}.quantity_spec == kind_of<isq::thermodynamic_temperature>);
+static_assert(quantity_point{20 * relative(deg_C)}.unit == si::degree_Celsius);
+static_assert(quantity_point{20 * relative(deg_C)}.quantity_spec == kind_of<isq::thermodynamic_temperature>);
 
 #if MP_UNITS_HOSTED
 using namespace std::chrono_literals;
diff --git a/test/static/usc_test.cpp b/test/static/usc_test.cpp
index 099a710f..480c5c57 100644
--- a/test/static/usc_test.cpp
+++ b/test/static/usc_test.cpp
@@ -126,6 +126,7 @@ static_assert(isq::mass(1 * lb_t) == isq::mass(12 * oz_t));
 static_assert(isq::pressure(1'000 * inHg) == isq::pressure(3'386'389 * si::pascal));
 
 // Temperature
-static_assert(isq::thermodynamic_temperature(9 * deg_F) == isq::thermodynamic_temperature(5 * si::degree_Celsius));
+static_assert(isq::thermodynamic_temperature(9 * relative(deg_F)) ==
+              isq::thermodynamic_temperature(5 * relative(si::degree_Celsius)));
 
 }  // namespace