diff --git a/src/primitive/impl.cppm b/src/primitive/impl.cppm
index 4b17d15..0f1ad91 100644
--- a/src/primitive/impl.cppm
+++ b/src/primitive/impl.cppm
@@ -1,4 +1,5 @@
 module;
+#include <cstddef>
 #include <cstdint>
 #include <tuple>
 #include <type_traits>
@@ -234,6 +235,20 @@ private:
   value_type value_;
 };
 
+template <policy::policy_type... Policies, underlying_type T>
+constexpr auto with(T value) noexcept(
+    noexcept(primitive<std::remove_cv_t<T>, Policies...>{value}))
+    -> primitive<std::remove_cv_t<T>, Policies...> {
+  return primitive<std::remove_cv_t<T>, Policies...>{value};
+}
+
+template <policy::policy_type... Policies, underlying_type T>
+constexpr auto with(std::tuple<Policies...>, T value) noexcept(
+    noexcept(primitive<std::remove_cv_t<T>, Policies...>{value}))
+    -> primitive<std::remove_cv_t<T>, Policies...> {
+  return primitive<std::remove_cv_t<T>, Policies...>{value};
+}
+
 namespace types {
 template <policy::policy_type... Policies>
 using Bool = primitive<bool, Policies...>;
@@ -258,6 +273,10 @@ using U32 = primitive<std::uint32_t, Policies...>;
 template <policy::policy_type... Policies>
 using U64 = primitive<std::uint64_t, Policies...>;
 template <policy::policy_type... Policies>
+using Size = primitive<std::size_t, Policies...>;
+template <policy::policy_type... Policies>
+using Diff = primitive<std::ptrdiff_t, Policies...>;
+template <policy::policy_type... Policies>
 using I8 = primitive<std::int8_t, Policies...>;
 template <policy::policy_type... Policies>
 using I16 = primitive<std::int16_t, Policies...>;
diff --git a/src/primitive/traits.cppm b/src/primitive/traits.cppm
index bc3af30..0168c7d 100644
--- a/src/primitive/traits.cppm
+++ b/src/primitive/traits.cppm
@@ -13,6 +13,8 @@ namespace mcpplibs::primitives::meta::details {
 
 template <typename T> struct primitive_traits_impl;
 
+template <typename T, typename PoliciesTuple> struct make_primitive;
+
 template <underlying_type T, policy::policy_type... Policies>
 struct primitive_traits_impl<primitive<T, Policies...>> {
   using value_type = T;
@@ -27,21 +29,19 @@ struct primitive_traits_impl<primitive<T, Policies...>> {
       policy::resolve_policy_t<policy::category::concurrency, Policies...>;
 };
 
+template <underlying_type T, policy::policy_type... Policies>
+struct make_primitive<T, std::tuple<Policies...>> {
+  using type = primitive<T, Policies...>;
+};
+
 } // namespace mcpplibs::primitives::meta::details
 
 // Public API exported from this module.
 export namespace mcpplibs::primitives::meta {
 using policy_category = policy::category;
 
-template <typename T, typename PoliciesTuple> struct make_primitive;
-
-template <underlying_type T, policy::policy_type... Policies>
-struct make_primitive<T, std::tuple<Policies...>> {
-  using type = primitive<T, Policies...>;
-};
-
 template <underlying_type T, typename PoliciesTuple>
-using make_primitive_t = make_primitive<T, PoliciesTuple>::type;
+using make_primitive_t = details::make_primitive<T, PoliciesTuple>::type;
 
 using default_policies =
     std::tuple<policy::resolve_policy_t<policy::category::value>,
diff --git a/src/primitives.cppm b/src/primitives.cppm
index cfa671f..86ee0e2 100644
--- a/src/primitives.cppm
+++ b/src/primitives.cppm
@@ -8,3 +8,4 @@ export import mcpplibs.primitives.primitive;
 export import mcpplibs.primitives.operations;
 export import mcpplibs.primitives.algorithms;
 export import mcpplibs.primitives.conversion;
+export import mcpplibs.primitives.underlying.literals;
diff --git a/src/underlying/impl.cppm b/src/underlying/impl.cppm
index dbfccd7..6c39c3a 100644
--- a/src/underlying/impl.cppm
+++ b/src/underlying/impl.cppm
@@ -33,5 +33,3 @@ struct mcpplibs::primitives::underlying::traits<T> {
 
   static constexpr bool is_valid_rep(rep_type) noexcept { return true; }
 };
-
-
diff --git a/src/underlying/literals.cppm b/src/underlying/literals.cppm
new file mode 100644
index 0000000..b104166
--- /dev/null
+++ b/src/underlying/literals.cppm
@@ -0,0 +1,278 @@
+module;
+
+#include <concepts>
+#include <cstddef> // NOLINT
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <type_traits>
+
+export module mcpplibs.primitives.underlying.literals;
+
+import mcpplibs.primitives.algorithms.limits;
+import mcpplibs.primitives.conversion.traits;
+import mcpplibs.primitives.underlying;
+
+namespace mcpplibs::primitives::underlying::details {
+
+template <conversion::risk::kind Kind>
+consteval auto throw_literal_risk() -> void {
+  if constexpr (Kind == conversion::risk::kind::overflow ||
+                Kind == conversion::risk::kind::underflow) {
+    throw std::out_of_range{
+        "numeric literal is out of range for target underlying type"};
+  } else if constexpr (Kind == conversion::risk::kind::precision_loss) {
+    throw std::invalid_argument{
+        "numeric literal loses precision for target underlying type"};
+  } else if constexpr (Kind == conversion::risk::kind::domain_error) {
+    throw std::invalid_argument{
+        "numeric literal must be finite for target underlying type"};
+  } else {
+    throw std::invalid_argument{
+        "numeric literal is not representable for target underlying type"};
+  }
+}
+
+template <std::floating_point T>
+consteval auto ordered(T value) -> bool {
+  return (value < static_cast<T>(0)) || (value >= static_cast<T>(0));
+}
+
+template <std::floating_point T>
+consteval auto finite(T value) -> bool {
+  return ordered(value) &&
+         value >= algorithms::lowest_value<T>() &&
+         value <= algorithms::max_value<T>();
+}
+
+template <typename To, typename From>
+consteval auto out_of_floating_range(From value) -> bool {
+  using value_type = std::remove_cv_t<To>;
+  auto const normalized = static_cast<long double>(value);
+  auto const lowest =
+      static_cast<long double>(algorithms::lowest_value<value_type>());
+  auto const max = static_cast<long double>(algorithms::max_value<value_type>());
+  return normalized < lowest || normalized > max;
+}
+
+template <std::integral To>
+consteval auto checked_integral_literal(unsigned long long value) -> To {
+  using value_type = std::remove_cv_t<To>;
+  constexpr auto max_value =
+      static_cast<unsigned long long>(algorithms::max_value<value_type>());
+
+  if (value > max_value) {
+    throw_literal_risk<conversion::risk::kind::overflow>();
+  }
+
+  return static_cast<value_type>(value);
+}
+
+template <std::floating_point To, std_numeric From>
+consteval auto checked_floating_literal(From value) -> To {
+  using source_type = std::remove_cv_t<From>;
+  using value_type = std::remove_cv_t<To>;
+
+  if constexpr (std_floating<source_type>) {
+    if (!ordered(value)) {
+      throw_literal_risk<conversion::risk::kind::domain_error>();
+    }
+  }
+
+  if (out_of_floating_range<value_type>(value)) {
+    if constexpr (std::signed_integral<source_type> || std_floating<source_type>) {
+      if (value < static_cast<source_type>(0)) {
+        throw_literal_risk<conversion::risk::kind::underflow>();
+      }
+    }
+    throw_literal_risk<conversion::risk::kind::overflow>();
+  }
+
+  auto const converted = static_cast<value_type>(value);
+
+  if constexpr (std_floating<value_type>) {
+    if (!finite(converted)) {
+      if constexpr (std::signed_integral<source_type> || std_floating<source_type>) {
+        if (value < static_cast<source_type>(0)) {
+          throw_literal_risk<conversion::risk::kind::underflow>();
+        }
+      }
+      throw_literal_risk<conversion::risk::kind::overflow>();
+    }
+  }
+
+  return converted;
+}
+
+template <std::floating_point To, std_numeric From>
+consteval auto exact_floating_literal(From value) -> To {
+  using source_type = std::remove_cv_t<From>;
+  using value_type = std::remove_cv_t<To>;
+
+  auto const converted = checked_floating_literal<value_type>(value);
+
+  if constexpr (std::integral<source_type>) {
+    if (static_cast<source_type>(converted) != value) {
+      throw_literal_risk<conversion::risk::kind::precision_loss>();
+    }
+  } else {
+    auto const roundtrip = static_cast<source_type>(converted);
+    if (!ordered(roundtrip)) {
+      throw_literal_risk<conversion::risk::kind::domain_error>();
+    }
+    if (roundtrip != value) {
+      if (converted == static_cast<value_type>(0) &&
+          value != static_cast<source_type>(0)) {
+        throw_literal_risk<conversion::risk::kind::underflow>();
+      }
+      throw_literal_risk<conversion::risk::kind::precision_loss>();
+    }
+  }
+
+  return converted;
+}
+
+template <char... Cs>
+consteval auto parse_unsigned_decimal_literal() -> unsigned long long {
+  constexpr char input[] {Cs..., '\0'};
+  constexpr auto max_value = std::numeric_limits<unsigned long long>::max();
+
+  unsigned long long value {};
+  for (std::size_t i = 0; i < sizeof...(Cs); ++i) {
+    auto const ch = input[i];
+    if (ch < '0' || ch > '9') {
+      throw std::invalid_argument{"invalid integer literal"};
+    }
+
+    auto const digit = static_cast<unsigned long long>(ch - '0');
+    if (value > max_value / 10ULL ||
+        (value == max_value / 10ULL && digit > max_value % 10ULL)) {
+      throw std::out_of_range{"integer literal is out of range"};
+    }
+
+    value = value * 10ULL + digit;
+  }
+
+  return value;
+}
+
+template <std::integral To, char... Cs>
+consteval auto literal_integral() -> To {
+  return checked_integral_literal<To>(parse_unsigned_decimal_literal<Cs...>());
+}
+
+} // namespace mcpplibs::primitives::underlying::details
+
+export namespace mcpplibs::primitives::literals {
+
+consteval auto operator""_uchar(const char value) -> unsigned char {
+  return static_cast<unsigned char>(value);
+}
+
+consteval auto operator""_char8(const char8_t value) -> char8_t { return value; }
+
+consteval auto operator""_char16(const char16_t value) -> char16_t { return value; }
+
+consteval auto operator""_char32(const char32_t value) -> char32_t { return value; }
+
+consteval auto operator""_wchar(const wchar_t value) -> wchar_t { return value; }
+
+template <char... Cs>
+consteval auto operator""_u8() -> std::uint8_t {
+  return underlying::details::literal_integral<std::uint8_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_u16() -> std::uint16_t {
+  return underlying::details::literal_integral<std::uint16_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_u32() -> std::uint32_t {
+  return underlying::details::literal_integral<std::uint32_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_u64() -> std::uint64_t {
+  return underlying::details::literal_integral<std::uint64_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_size() -> std::size_t {
+  return underlying::details::literal_integral<std::size_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_diff() -> std::ptrdiff_t {
+  return underlying::details::literal_integral<std::ptrdiff_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_i8() -> std::int8_t {
+  return underlying::details::literal_integral<std::int8_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_i16() -> std::int16_t {
+  return underlying::details::literal_integral<std::int16_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_i32() -> std::int32_t {
+  return underlying::details::literal_integral<std::int32_t, Cs...>();
+}
+
+template <char... Cs>
+consteval auto operator""_i64() -> std::int64_t {
+  return underlying::details::literal_integral<std::int64_t, Cs...>();
+}
+
+consteval auto operator""_f32(const unsigned long long value) -> float {
+  return underlying::details::checked_floating_literal<float>(value);
+}
+
+consteval auto operator""_f32(const long double value) -> float {
+  return underlying::details::checked_floating_literal<float>(value);
+}
+
+consteval auto operator""_f32e(const unsigned long long value) -> float {
+  return underlying::details::exact_floating_literal<float>(value);
+}
+
+consteval auto operator""_f32e(const long double value) -> float {
+  return underlying::details::exact_floating_literal<float>(value);
+}
+
+consteval auto operator""_f64(const unsigned long long value) -> double {
+  return underlying::details::checked_floating_literal<double>(value);
+}
+
+consteval auto operator""_f64(const long double value) -> double {
+  return underlying::details::checked_floating_literal<double>(value);
+}
+
+consteval auto operator""_f64e(const unsigned long long value) -> double {
+  return underlying::details::exact_floating_literal<double>(value);
+}
+
+consteval auto operator""_f64e(const long double value) -> double {
+  return underlying::details::exact_floating_literal<double>(value);
+}
+
+consteval auto operator""_f80(const unsigned long long value) -> long double {
+  return underlying::details::checked_floating_literal<long double>(value);
+}
+
+consteval auto operator""_f80(const long double value) -> long double {
+  return underlying::details::checked_floating_literal<long double>(value);
+}
+
+consteval auto operator""_f80e(const unsigned long long value) -> long double {
+  return underlying::details::exact_floating_literal<long double>(value);
+}
+
+consteval auto operator""_f80e(const long double value) -> long double {
+  return underlying::details::exact_floating_literal<long double>(value);
+}
+
+} // namespace mcpplibs::primitives::literals
diff --git a/tests/basic/primitive/factory/test_make_primitive.cpp b/tests/basic/primitive/factory/test_make_primitive.cpp
new file mode 100644
index 0000000..54d75ae
--- /dev/null
+++ b/tests/basic/primitive/factory/test_make_primitive.cpp
@@ -0,0 +1,74 @@
+#include <gtest/gtest.h>
+#include <type_traits>
+
+import mcpplibs.primitives;
+
+#include "../../support/underlying_custom_types.hpp"
+
+using namespace mcpplibs::primitives;
+using namespace mcpplibs::primitives::literals;
+using namespace mcpplibs::primitives::test_support::underlying;
+
+TEST(PrimitiveFactoryTest, MakesPrimitiveFromDeducedStdUnderlying) {
+  using expected_t =
+      types::I32<policy::value::checked, policy::error::expected>;
+
+  auto value = with<policy::value::checked, policy::error::expected>(42_i32);
+
+  static_assert(std::same_as<decltype(value), expected_t>);
+  EXPECT_EQ(value.load(), 42);
+}
+
+TEST(PrimitiveFactoryTest, UsesDefaultPoliciesWhenNoPolicyIsSpecified) {
+  using expected_t = types::I32<>;
+  using meta_t = meta::traits<expected_t>;
+
+  auto value = with(42_i32);
+
+  static_assert(std::same_as<decltype(value), expected_t>);
+  static_assert(std::same_as<meta_t::value_policy,
+                             policy::defaults::value>);
+  static_assert(
+      std::same_as<meta_t::type_policy, policy::defaults::type>);
+  static_assert(
+      std::same_as<meta_t::error_policy, policy::defaults::error>);
+  static_assert(std::same_as<meta_t::concurrency_policy,
+                             policy::defaults::concurrency>);
+  EXPECT_EQ(value.load(), 42);
+}
+
+TEST(PrimitiveFactoryTest, DeducesSizeAndDiffPrimitiveAliases) {
+  auto sizeValue = with(42_size);
+  auto diffValue = with(42_diff);
+
+  static_assert(std::same_as<decltype(sizeValue), types::Size<>>);
+  static_assert(std::same_as<decltype(diffValue), types::Diff<>>);
+  EXPECT_EQ(sizeValue.load(), static_cast<std::size_t>(42));
+  EXPECT_EQ(diffValue.load(), static_cast<std::ptrdiff_t>(42));
+}
+
+TEST(PrimitiveFactoryTest, AcceptsPoliciesTupleInput) {
+  using policies_t =
+      meta::traits<types::I32<policy::value::checked,
+                              policy::error::expected>>::policies;
+  using expected_t = meta::make_primitive_t<std::int32_t, policies_t>;
+
+  auto value1 = with(policies_t{}, 42_i32);
+  auto value2 = with(meta::traits<decltype(value1)>::policies{}, 42_i32);
+
+  static_assert(std::same_as<decltype(value1), expected_t>);
+  static_assert(std::same_as<decltype(value2), expected_t>);
+  EXPECT_EQ(value1.load(), 42);
+  EXPECT_EQ(value2.load(), 42_i32);
+}
+
+TEST(PrimitiveFactoryTest, MakesPrimitiveFromDeducedCustomUnderlying) {
+  using expected_t =
+      primitive<UserInteger, policy::value::checked, policy::type::compatible>;
+
+  auto value =
+      with<policy::value::checked, policy::type::compatible>(UserInteger{7});
+
+  static_assert(std::same_as<decltype(value), expected_t>);
+  EXPECT_EQ(value.load().value, 7);
+}
diff --git a/tests/basic/underlying/literals/test_literals.cpp b/tests/basic/underlying/literals/test_literals.cpp
new file mode 100644
index 0000000..970f0da
--- /dev/null
+++ b/tests/basic/underlying/literals/test_literals.cpp
@@ -0,0 +1,129 @@
+#include <cstddef>
+#include <cstdint>
+#include <gtest/gtest.h>
+#include <type_traits>
+
+import mcpplibs.primitives.underlying.literals;
+
+using namespace mcpplibs::primitives::literals;
+
+namespace {
+
+template <auto Value> struct literal_value_tag;
+
+template <typename Probe>
+concept literal_available = requires { typename literal_value_tag<Probe::value()>; };
+
+struct U8OverflowProbe {
+  static consteval auto value() { return 256_u8; }
+};
+
+struct I8OverflowProbe {
+  static consteval auto value() { return 128_i8; }
+};
+
+struct F32ExactPrecisionLossProbe {
+  static consteval auto value() { return 16777217_f32e; }
+};
+
+struct F64ExactPrecisionLossProbe {
+  static consteval auto value() { return 9007199254740993_f64e; }
+};
+
+struct F32OverflowProbe {
+  static consteval auto value() { return 1.0e39_f32; }
+};
+
+struct F32ExactOverflowProbe {
+  static consteval auto value() { return 1.0e39_f32e; }
+};
+
+struct F32ExactUnderflowProbe {
+  static consteval auto value() { return 1.0e-50_f32e; }
+};
+
+static_assert(!literal_available<U8OverflowProbe>);
+static_assert(!literal_available<I8OverflowProbe>);
+static_assert(!literal_available<F32ExactPrecisionLossProbe>);
+static_assert(!literal_available<F64ExactPrecisionLossProbe>);
+static_assert(!literal_available<F32OverflowProbe>);
+static_assert(!literal_available<F32ExactOverflowProbe>);
+static_assert(!literal_available<F32ExactUnderflowProbe>);
+
+} // namespace
+
+TEST(UnderlyingLiteralsTest, IntegerLiteralsReturnExpectedUnderlyingTypes) {
+  static_assert(std::same_as<decltype(42_u8), std::uint8_t>);
+  static_assert(std::same_as<decltype(42_u16), std::uint16_t>);
+  static_assert(std::same_as<decltype(42_u32), std::uint32_t>);
+  static_assert(std::same_as<decltype(42_u64), std::uint64_t>);
+  static_assert(std::same_as<decltype(42_size), std::size_t>);
+  static_assert(std::same_as<decltype(42_diff), std::ptrdiff_t>);
+  static_assert(std::same_as<decltype(42_i8), std::int8_t>);
+  static_assert(std::same_as<decltype(42_i16), std::int16_t>);
+  static_assert(std::same_as<decltype(42_i32), std::int32_t>);
+  static_assert(std::same_as<decltype(42_i64), std::int64_t>);
+
+  EXPECT_EQ(42_u8, static_cast<std::uint8_t>(42));
+  EXPECT_EQ(42_u16, static_cast<std::uint16_t>(42));
+  EXPECT_EQ(42_u32, static_cast<std::uint32_t>(42));
+  EXPECT_EQ(42_u64, static_cast<std::uint64_t>(42));
+  EXPECT_EQ(42_size, static_cast<std::size_t>(42));
+  EXPECT_EQ(42_diff, static_cast<std::ptrdiff_t>(42));
+  EXPECT_EQ(42_i8, static_cast<std::int8_t>(42));
+  EXPECT_EQ(42_i16, static_cast<std::int16_t>(42));
+  EXPECT_EQ(42_i32, static_cast<std::int32_t>(42));
+  EXPECT_EQ(42_i64, static_cast<std::int64_t>(42));
+}
+
+TEST(UnderlyingLiteralsTest, FloatingLiteralsReturnExpectedUnderlyingTypes) {
+  static_assert(std::same_as<decltype(1.25_f32), float>);
+  static_assert(std::same_as<decltype(1.25_f32e), float>);
+  static_assert(std::same_as<decltype(1.25_f64), double>);
+  static_assert(std::same_as<decltype(1.25_f64e), double>);
+  static_assert(std::same_as<decltype(1.25_f80), long double>);
+  static_assert(std::same_as<decltype(1.25_f80e), long double>);
+  static_assert(std::same_as<decltype(16777216_f32), float>);
+  static_assert(std::same_as<decltype(16777216_f32e), float>);
+  static_assert(std::same_as<decltype(16777217_f32), float>);
+  static_assert(std::same_as<decltype(9007199254740992_f64), double>);
+  static_assert(std::same_as<decltype(9007199254740992_f64e), double>);
+  static_assert(std::same_as<decltype(9007199254740993_f64), double>);
+  static_assert(std::same_as<decltype(0.1_f32), float>);
+  static_assert(std::same_as<decltype(0.1_f64), double>);
+
+  EXPECT_FLOAT_EQ(1.25_f32, 1.25f);
+  EXPECT_FLOAT_EQ(1.25_f32e, 1.25f);
+  EXPECT_DOUBLE_EQ(1.25_f64, 1.25);
+  EXPECT_DOUBLE_EQ(1.25_f64e, 1.25);
+  EXPECT_EQ(1.25_f80, static_cast<long double>(1.25));
+  EXPECT_EQ(1.25_f80e, static_cast<long double>(1.25));
+  EXPECT_FLOAT_EQ(16777216_f32, 16777216.0f);
+  EXPECT_FLOAT_EQ(16777216_f32e, 16777216.0f);
+  EXPECT_FLOAT_EQ(16777217_f32, static_cast<float>(16777217.0L));
+  EXPECT_DOUBLE_EQ(9007199254740992_f64, 9007199254740992.0);
+  EXPECT_DOUBLE_EQ(9007199254740992_f64e, 9007199254740992.0);
+  EXPECT_DOUBLE_EQ(9007199254740993_f64, static_cast<double>(9007199254740993.0L));
+  EXPECT_FLOAT_EQ(0.1_f32, static_cast<float>(0.1L));
+  EXPECT_FLOAT_EQ(2_f32, 2.0f);
+  EXPECT_FLOAT_EQ(2_f32e, 2.0f);
+  EXPECT_DOUBLE_EQ(0.1_f64, static_cast<double>(0.1L));
+  EXPECT_DOUBLE_EQ(2_f64, 2.0);
+  EXPECT_DOUBLE_EQ(2_f64e, 2.0);
+  EXPECT_EQ(2_f80, static_cast<long double>(2.0));
+  EXPECT_EQ(2_f80e, static_cast<long double>(2.0));
+}
+
+TEST(UnderlyingLiteralsTest, CharacterLiteralsReturnExpectedUnderlyingTypes) {
+  static_assert(std::same_as<decltype('A'_uchar), unsigned char>);
+  static_assert(std::same_as<decltype(u8'A'_char8), char8_t>);
+  static_assert(std::same_as<decltype(u'A'_char16), char16_t>);
+  static_assert(std::same_as<decltype(U'A'_char32), char32_t>);
+  static_assert(std::same_as<decltype(L'A'_wchar), wchar_t>);
+
+  EXPECT_EQ('A'_uchar, static_cast<unsigned char>('A'));
+  EXPECT_EQ(u8'A'_char8, u8'A');
+  EXPECT_EQ(u'A'_char16, u'A');
+  EXPECT_EQ(U'A'_char32, U'A');
+  EXPECT_EQ(L'A'_wchar, L'A');
+}