diff --git a/include/log/catalog/arguments.hpp b/include/log/catalog/arguments.hpp
new file mode 100644
index 00000000..eb1bf7ff
--- /dev/null
+++ b/include/log/catalog/arguments.hpp
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stdx/type_traits.hpp>
+
+#include <concepts>
+#include <cstdint>
+#include <type_traits>
+
+template <typename> struct encode_32;
+template <typename> struct encode_64;
+template <typename> struct encode_u32;
+template <typename> struct encode_u64;
+
+namespace logging {
+template <typename T>
+concept signed_packable = std::signed_integral<stdx::underlying_type_t<T>> and
+                          sizeof(T) <= sizeof(std::int64_t);
+
+template <typename T>
+concept unsigned_packable =
+    std::unsigned_integral<stdx::underlying_type_t<T>> and
+    sizeof(T) <= sizeof(std::int64_t);
+
+template <typename T>
+concept float_packable = std::floating_point<stdx::underlying_type_t<T>> and
+                         sizeof(T) <= sizeof(std::int64_t);
+
+template <typename T>
+concept packable =
+    signed_packable<T> or unsigned_packable<T> or float_packable<T>;
+
+template <typename T> struct encoding;
+
+template <signed_packable T> struct encoding<T> {
+    using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
+                                         encode_32<T>, encode_64<T>>;
+    using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
+                                       std::int32_t, std::int64_t>;
+};
+
+template <unsigned_packable T> struct encoding<T> {
+    using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
+                                         encode_u32<T>, encode_u64<T>>;
+    using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
+                                       std::uint32_t, std::uint64_t>;
+};
+
+template <float_packable T> struct encoding<T> {
+    using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
+                                         encode_u32<T>, encode_u64<T>>;
+    using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
+                                       std::uint32_t, std::uint64_t>;
+};
+
+struct default_arg_packer {
+    template <packable T> using pack_as_t = typename encoding<T>::pack_t;
+    template <packable T> using encode_as_t = typename encoding<T>::encode_t;
+};
+} // namespace logging
diff --git a/include/log/catalog/builder.hpp b/include/log/catalog/builder.hpp
index b57de704..02405c27 100644
--- a/include/log/catalog/builder.hpp
+++ b/include/log/catalog/builder.hpp
@@ -17,7 +17,7 @@ namespace logging::binary {
     }
 
     CONSTEVAL auto operator()(auto &&) const {
-        return logging::mipi::default_builder{};
+        return logging::mipi::default_builder<>{};
     }
 } get_builder;
 } // namespace logging::binary
diff --git a/include/log/catalog/catalog.hpp b/include/log/catalog/catalog.hpp
index c2371d35..8ee4709a 100644
--- a/include/log/catalog/catalog.hpp
+++ b/include/log/catalog/catalog.hpp
@@ -15,8 +15,3 @@ using module_id = std::uint32_t;
 
 template <typename> extern auto catalog() -> string_id;
 template <typename> extern auto module() -> module_id;
-
-template <typename> struct encode_32;
-template <typename> struct encode_64;
-template <typename> struct encode_u32;
-template <typename> struct encode_u64;
diff --git a/include/log/catalog/encoder.hpp b/include/log/catalog/encoder.hpp
index 853bea23..872ddabf 100644
--- a/include/log/catalog/encoder.hpp
+++ b/include/log/catalog/encoder.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <log/catalog/arguments.hpp>
 #include <log/catalog/builder.hpp>
 #include <log/catalog/catalog.hpp>
 #include <log/log.hpp>
diff --git a/include/log/catalog/mipi_builder.hpp b/include/log/catalog/mipi_builder.hpp
index dc299b15..61fb86d2 100644
--- a/include/log/catalog/mipi_builder.hpp
+++ b/include/log/catalog/mipi_builder.hpp
@@ -1,8 +1,10 @@
 #pragma once
 
+#include <log/catalog/arguments.hpp>
 #include <log/catalog/catalog.hpp>
 #include <log/catalog/mipi_messages.hpp>
 
+#include <stdx/bit.hpp>
 #include <stdx/compiler.hpp>
 #include <stdx/type_traits.hpp>
 #include <stdx/utility.hpp>
@@ -16,46 +18,19 @@
 
 namespace logging::mipi {
 template <typename T>
-concept signed_packable = std::signed_integral<stdx::underlying_type_t<T>> and
-                          sizeof(T) <= sizeof(std::int64_t);
+concept packer = std::integral<typename T::template pack_as_t<int>> and
+                 requires { typename T::template encode_as_t<int>; };
 
-template <typename T>
-concept unsigned_packable =
-    std::unsigned_integral<stdx::underlying_type_t<T>> and
-    sizeof(T) <= sizeof(std::int64_t);
-
-template <typename T>
-concept packable = signed_packable<T> or unsigned_packable<T>;
-
-template <typename T> struct encoding;
-
-template <signed_packable T> struct encoding<T> {
-    using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
-                                         encode_32<T>, encode_64<T>>;
-    using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
-                                       std::int32_t, std::int64_t>;
-};
+template <typename, packer> struct builder;
 
-template <unsigned_packable T> struct encoding<T> {
-    using encode_t = stdx::conditional_t<sizeof(T) <= sizeof(std::int32_t),
-                                         encode_u32<T>, encode_u64<T>>;
-    using pack_t = stdx::conditional_t<sizeof(T) <= sizeof(std::uint32_t),
-                                       std::uint32_t, std::uint64_t>;
-};
-
-template <packable T> using pack_as_t = typename encoding<T>::pack_t;
-template <packable T> using encode_as_t = typename encoding<T>::encode_t;
-
-template <typename> struct builder;
-
-template <> struct builder<defn::short32_msg_t> {
+template <packer P> struct builder<defn::short32_msg_t, P> {
     template <auto Level> static auto build(string_id id, module_id) {
         using namespace msg;
         return owning<defn::short32_msg_t>{"payload"_field = id};
     }
 };
 
-template <typename Storage> struct catalog_builder {
+template <typename Storage, packer P> struct catalog_builder {
     template <auto Level, packable... Ts>
     static auto build(string_id id, module_id m, Ts... args) {
         using namespace msg;
@@ -66,8 +41,16 @@ template <typename Storage> struct catalog_builder {
         constexpr auto header_size = defn::catalog_msg_t::size<V>::value;
 
         auto const pack_arg = []<typename T>(V *p, T arg) -> V * {
-            auto const packed = stdx::to_le(stdx::as_unsigned(
-                static_cast<pack_as_t<T>>(stdx::to_underlying(arg))));
+            typename P::template pack_as_t<T> converted{};
+            if constexpr (sizeof(stdx::to_underlying(arg)) ==
+                          sizeof(converted)) {
+                converted = stdx::bit_cast<decltype(converted)>(
+                    stdx::to_underlying(arg));
+            } else {
+                converted =
+                    static_cast<decltype(converted)>(stdx::to_underlying(arg));
+            }
+            auto const packed = stdx::to_le(stdx::as_unsigned(converted));
             std::memcpy(p, &packed, sizeof(packed));
             return p + stdx::sized8{sizeof(packed)}.in<V>();
         };
@@ -80,7 +63,7 @@ template <typename Storage> struct catalog_builder {
     }
 };
 
-template <> struct builder<defn::catalog_msg_t> {
+template <packer P> struct builder<defn::catalog_msg_t, P> {
     template <auto Level, typename... Ts>
     static auto build(string_id id, module_id m, Ts... args) {
         using namespace msg;
@@ -88,40 +71,41 @@ template <> struct builder<defn::catalog_msg_t> {
             constexpr auto header_size =
                 defn::catalog_msg_t::size<std::uint32_t>::value;
             constexpr auto payload_size =
-                stdx::sized8{(sizeof(id) + ... + sizeof(pack_as_t<Ts>))}
+                stdx::sized8{(sizeof(id) + ... +
+                              sizeof(typename P::template pack_as_t<Ts>))}
                     .in<std::uint32_t>();
             using storage_t =
                 std::array<std::uint32_t, header_size + payload_size>;
-            return catalog_builder<storage_t>{}.template build<Level>(id, m,
-                                                                      args...);
+            return catalog_builder<storage_t, P>{}.template build<Level>(
+                id, m, args...);
         } else {
             constexpr auto header_size =
                 defn::catalog_msg_t::size<std::uint8_t>::value;
             constexpr auto payload_size =
-                (sizeof(id) + ... + sizeof(pack_as_t<Ts>));
+                (sizeof(id) + ... + sizeof(typename P::template pack_as_t<Ts>));
             using storage_t =
                 std::array<std::uint8_t, header_size + payload_size>;
-            return catalog_builder<storage_t>{}.template build<Level>(id, m,
-                                                                      args...);
+            return catalog_builder<storage_t, P>{}.template build<Level>(
+                id, m, args...);
         }
     }
 };
 
-template <> struct builder<defn::compact32_build_msg_t> {
+template <packer P> struct builder<defn::compact32_build_msg_t, P> {
     template <auto Version> static auto build() {
         using namespace msg;
         return owning<defn::compact32_build_msg_t>{"build_id"_field = Version};
     }
 };
 
-template <> struct builder<defn::compact64_build_msg_t> {
+template <packer P> struct builder<defn::compact64_build_msg_t, P> {
     template <auto Version> static auto build() {
         using namespace msg;
         return owning<defn::compact64_build_msg_t>{"build_id"_field = Version};
     }
 };
 
-template <> struct builder<defn::normal_build_msg_t> {
+template <packer P> struct builder<defn::normal_build_msg_t, P> {
     template <auto Version, stdx::ct_string S> static auto build() {
         using namespace msg;
         constexpr auto header_size =
@@ -141,13 +125,14 @@ template <> struct builder<defn::normal_build_msg_t> {
     }
 };
 
-struct default_builder {
+template <packer P = logging::default_arg_packer> struct default_builder {
     template <auto Level, packable... Ts>
     static auto build(string_id id, module_id m, Ts... args) {
         if constexpr (sizeof...(Ts) == 0u) {
-            return builder<defn::short32_msg_t>{}.template build<Level>(id, m);
+            return builder<defn::short32_msg_t, P>{}.template build<Level>(id,
+                                                                           m);
         } else {
-            return builder<defn::catalog_msg_t>{}.template build<Level>(
+            return builder<defn::catalog_msg_t, P>{}.template build<Level>(
                 id, m, args...);
         }
     }
@@ -155,18 +140,18 @@ struct default_builder {
     template <auto Version, stdx::ct_string S = ""> auto build_version() {
         using namespace msg;
         if constexpr (S.empty() and stdx::bit_width(Version) <= 22) {
-            return builder<defn::compact32_build_msg_t>{}
+            return builder<defn::compact32_build_msg_t, P>{}
                 .template build<Version>();
         } else if constexpr (S.empty() and stdx::bit_width(Version) <= 54) {
-            return builder<defn::compact64_build_msg_t>{}
+            return builder<defn::compact64_build_msg_t, P>{}
                 .template build<Version>();
         } else {
-            return builder<defn::normal_build_msg_t>{}
+            return builder<defn::normal_build_msg_t, P>{}
                 .template build<Version, S>();
         }
     }
 
     template <template <typename...> typename F, typename... Args>
-    using convert_args = F<encode_as_t<Args>...>;
+    using convert_args = F<typename P::template encode_as_t<Args>...>;
 };
 } // namespace logging::mipi
diff --git a/test/log/catalog2b_lib.cpp b/test/log/catalog2b_lib.cpp
index 4f4cebb3..858807ca 100644
--- a/test/log/catalog2b_lib.cpp
+++ b/test/log/catalog2b_lib.cpp
@@ -22,6 +22,8 @@ using log_env2b = stdx::make_env_t<logging::get_level, logging::level::TRACE>;
 } // namespace
 
 auto log_rt_enum_arg() -> void;
+auto log_rt_float_arg() -> void;
+auto log_rt_double_arg() -> void;
 
 auto log_rt_enum_arg() -> void {
     auto cfg = logging::binary::config{test_log_args_destination{}};
@@ -29,3 +31,17 @@ auto log_rt_enum_arg() -> void {
     cfg.logger.log_msg<log_env2b>(
         stdx::ct_format<"E string with {} placeholder">(E::value));
 }
+
+auto log_rt_float_arg() -> void {
+    auto cfg = logging::binary::config{test_log_args_destination{}};
+    using namespace ns;
+    cfg.logger.log_msg<log_env2b>(
+        stdx::ct_format<"Float string with {} placeholder">(3.14f));
+}
+
+auto log_rt_double_arg() -> void {
+    auto cfg = logging::binary::config{test_log_args_destination{}};
+    using namespace ns;
+    cfg.logger.log_msg<log_env2b>(
+        stdx::ct_format<"Double string with {} placeholder">(3.14));
+}
diff --git a/test/log/catalog_app.cpp b/test/log/catalog_app.cpp
index 5dcc1901..34690e89 100644
--- a/test/log/catalog_app.cpp
+++ b/test/log/catalog_app.cpp
@@ -21,6 +21,8 @@ extern auto log_with_non_default_module() -> void;
 extern auto log_with_fixed_module() -> void;
 extern auto log_with_fixed_string_id() -> void;
 extern auto log_with_fixed_module_id() -> void;
+extern auto log_rt_float_arg() -> void;
+extern auto log_rt_double_arg() -> void;
 
 TEST_CASE("log zero arguments", "[catalog]") {
     test_critical_section::count = 0;
@@ -58,6 +60,22 @@ TEST_CASE("log one 64-bit runtime argument", "[catalog]") {
     CHECK(log_calls == 1);
 }
 
+TEST_CASE("log one float runtime argument", "[catalog]") {
+    log_calls = 0;
+    test_critical_section::count = 0;
+    log_rt_float_arg();
+    CHECK(test_critical_section::count == 2);
+    CHECK(log_calls == 1);
+}
+
+TEST_CASE("log one double runtime argument", "[catalog]") {
+    log_calls = 0;
+    test_critical_section::count = 0;
+    log_rt_double_arg();
+    CHECK(test_critical_section::count == 2);
+    CHECK(log_calls == 1);
+}
+
 TEST_CASE("log one formatted runtime argument", "[catalog]") {
     log_calls = 0;
     test_critical_section::count = 0;
diff --git a/test/log/encoder.cpp b/test/log/encoder.cpp
index aabe010a..cfd78cbe 100644
--- a/test/log/encoder.cpp
+++ b/test/log/encoder.cpp
@@ -126,38 +126,60 @@ struct test_log_version_destination {
     }
 };
 
+template <logging::level Level> struct test_log_float_args_destination {
+    auto log_by_args(std::uint32_t header, auto, auto arg) {
+        constexpr auto Header = expected_msg_header(Level, test_module_id, 1);
+        CHECK(header == Header);
+        CHECK(stdx::bit_cast<float>(arg) == expected);
+        ++num_log_args_calls;
+    }
+    float expected{};
+};
+
+template <logging::level Level> struct test_log_double_args_destination {
+    auto log_by_args(std::uint32_t header, auto, std::uint32_t lo,
+                     std::uint32_t hi) {
+        constexpr auto Header = expected_msg_header(Level, test_module_id, 1);
+        CHECK(header == Header);
+        std::array arr{lo, hi};
+        CHECK(stdx::bit_cast<double>(arr) == expected);
+        ++num_log_args_calls;
+    }
+    double expected{};
+};
+
 using log_env = stdx::make_env_t<logging::get_level, logging::level::TRACE>;
 } // namespace
 
 template <> inline auto conc::injected_policy<> = test_conc_policy{};
 
 TEST_CASE("argument packing", "[mipi]") {
+    using P = logging::default_arg_packer;
+    static_assert(std::same_as<P::pack_as_t<std::int32_t>, std::int32_t>);
+    static_assert(std::same_as<P::pack_as_t<std::uint32_t>, std::uint32_t>);
+    static_assert(std::same_as<P::pack_as_t<std::int64_t>, std::int64_t>);
+    static_assert(std::same_as<P::pack_as_t<std::uint64_t>, std::uint64_t>);
+    static_assert(std::same_as<P::pack_as_t<char>, std::int32_t>);
+    static_assert(std::same_as<P::pack_as_t<unsigned char>, std::uint32_t>);
+    static_assert(std::same_as<P::pack_as_t<float>, std::uint32_t>);
+    static_assert(std::same_as<P::pack_as_t<double>, std::uint64_t>);
+}
+
+TEST_CASE("argument encoding", "[mipi]") {
+    using P = logging::default_arg_packer;
     static_assert(
-        std::same_as<logging::mipi::pack_as_t<std::int32_t>, std::int32_t>);
+        std::same_as<P::encode_as_t<std::int32_t>, encode_32<std::int32_t>>);
     static_assert(
-        std::same_as<logging::mipi::pack_as_t<std::uint32_t>, std::uint32_t>);
+        std::same_as<P::encode_as_t<std::uint32_t>, encode_u32<std::uint32_t>>);
     static_assert(
-        std::same_as<logging::mipi::pack_as_t<std::int64_t>, std::int64_t>);
+        std::same_as<P::encode_as_t<std::int64_t>, encode_64<std::int64_t>>);
     static_assert(
-        std::same_as<logging::mipi::pack_as_t<std::uint64_t>, std::uint64_t>);
-    static_assert(std::same_as<logging::mipi::pack_as_t<char>, std::int32_t>);
+        std::same_as<P::encode_as_t<std::uint64_t>, encode_u64<std::uint64_t>>);
+    static_assert(std::same_as<P::encode_as_t<char>, encode_32<char>>);
     static_assert(
-        std::same_as<logging::mipi::pack_as_t<unsigned char>, std::uint32_t>);
-}
-
-TEST_CASE("argument encoding", "[mipi]") {
-    static_assert(std::same_as<logging::mipi::encode_as_t<std::int32_t>,
-                               encode_32<std::int32_t>>);
-    static_assert(std::same_as<logging::mipi::encode_as_t<std::uint32_t>,
-                               encode_u32<std::uint32_t>>);
-    static_assert(std::same_as<logging::mipi::encode_as_t<std::int64_t>,
-                               encode_64<std::int64_t>>);
-    static_assert(std::same_as<logging::mipi::encode_as_t<std::uint64_t>,
-                               encode_u64<std::uint64_t>>);
-    static_assert(
-        std::same_as<logging::mipi::encode_as_t<char>, encode_32<char>>);
-    static_assert(std::same_as<logging::mipi::encode_as_t<unsigned char>,
-                               encode_u32<unsigned char>>);
+        std::same_as<P::encode_as_t<unsigned char>, encode_u32<unsigned char>>);
+    static_assert(std::same_as<P::encode_as_t<float>, encode_u32<float>>);
+    static_assert(std::same_as<P::encode_as_t<double>, encode_u64<double>>);
 }
 
 TEST_CASE("log zero arguments", "[mipi]") {
@@ -169,7 +191,7 @@ TEST_CASE("log zero arguments", "[mipi]") {
     CHECK(test_critical_section::count == 2);
 }
 
-TEST_CASE("log one 32-bit argument", "[mipi]") {
+TEST_CASE("log one integral 32-bit argument", "[mipi]") {
     CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
     test_critical_section::count = 0;
     auto cfg = logging::binary::config{
@@ -178,6 +200,15 @@ TEST_CASE("log one 32-bit argument", "[mipi]") {
     CHECK(test_critical_section::count == 2);
 }
 
+TEST_CASE("log one floating-point 32-bit argument", "[mipi]") {
+    CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
+    test_critical_section::count = 0;
+    auto cfg = logging::binary::config{
+        test_log_float_args_destination<logging::level::TRACE>{3.14f}};
+    cfg.logger.log_msg<log_env>(stdx::ct_format<"{}">(3.14f));
+    CHECK(test_critical_section::count == 2);
+}
+
 TEST_CASE("log one 64-bit argument", "[mipi]") {
     CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
     test_critical_section::count = 0;
@@ -189,6 +220,15 @@ TEST_CASE("log one 64-bit argument", "[mipi]") {
     CHECK(test_critical_section::count == 2);
 }
 
+TEST_CASE("log one floating-point 64-bit argument", "[mipi]") {
+    CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
+    test_critical_section::count = 0;
+    auto cfg = logging::binary::config{
+        test_log_double_args_destination<logging::level::TRACE>{3.14}};
+    cfg.logger.log_msg<log_env>(stdx::ct_format<"{}">(3.14));
+    CHECK(test_critical_section::count == 2);
+}
+
 TEST_CASE("log two arguments", "[mipi]") {
     CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
     test_critical_section::count = 0;
@@ -295,10 +335,11 @@ template <logging::level Level> struct test_catalog_args_destination {
     }
 };
 
-struct custom_builder : logging::mipi::default_builder {
-    template <auto Level, logging::mipi::packable... Ts>
+struct custom_builder : logging::mipi::default_builder<> {
+    template <auto Level, logging::packable... Ts>
     static auto build(string_id id, module_id m, Ts... args) {
-        return logging::mipi::builder<logging::mipi::defn::catalog_msg_t>{}
+        return logging::mipi::builder<logging::mipi::defn::catalog_msg_t,
+                                      logging::default_arg_packer>{}
             .template build<Level>(id, m, args...);
     }
 };
diff --git a/tools/gen_str_catalog.py b/tools/gen_str_catalog.py
index a6445a09..6661df4b 100755
--- a/tools/gen_str_catalog.py
+++ b/tools/gen_str_catalog.py
@@ -224,6 +224,7 @@ def make_cpp_module_defn(m: Module) -> str:
 def write_cpp(messages, modules, extra_headers: list[str], filename: str):
     with open(filename, "w") as f:
         f.write("\n".join(f'#include "{h}"' for h in extra_headers))
+        f.write("\n#include <log/catalog/arguments.hpp>\n")
         f.write("\n#include <log/catalog/catalog.hpp>\n\n")
         cpp_catalog_defns = [make_cpp_catalog_defn(m) for m in messages]
         f.write("\n".join(cpp_catalog_defns))
@@ -357,9 +358,11 @@ def arg_printf_spec(arg: str):
         "encode_u32": "%u",
         "encode_64": "%lld",
         "encode_u64": "%llu",
+        "float": "%f",
+        "double": "%f",
     }
-    enc, _ = arg_type_encoding(arg)
-    return printf_dict.get(enc, "%d")
+    enc, t = arg_type_encoding(arg)
+    return printf_dict.get(t, printf_dict.get(enc, "%d"))
 
 
 def serialize_messages(