diff --git a/include/meson.build b/include/meson.build
index 979478e..56f9c8e 100644
--- a/include/meson.build
+++ b/include/meson.build
@@ -13,6 +13,7 @@
   'stdplus/net/addr/ip.hpp',
   'stdplus/net/addr/subnet.hpp',
   'stdplus/numeric/endian.hpp',
+  'stdplus/numeric/str.hpp',
   'stdplus/pinned.hpp',
   'stdplus/raw.hpp',
   'stdplus/signal.hpp',
diff --git a/include/stdplus/numeric/str.hpp b/include/stdplus/numeric/str.hpp
new file mode 100644
index 0000000..ee80905
--- /dev/null
+++ b/include/stdplus/numeric/str.hpp
@@ -0,0 +1,111 @@
+#pragma once
+#include <stdplus/str/conv.hpp>
+
+#include <algorithm>
+#include <array>
+#include <bit>
+#include <concepts>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+namespace stdplus
+{
+
+namespace detail
+{
+
+inline constexpr auto maxBase = 36;
+
+inline constexpr auto singleIntTable = []() {
+    std::array<char, maxBase> ret;
+    for (int8_t i = 0; i < 10; ++i)
+    {
+        ret[i] = i + '0';
+    }
+    for (int8_t i = 0; i < 26; ++i)
+    {
+        ret[i + 10] = i + 'a';
+    }
+    static_assert(maxBase == 36);
+    return ret;
+}();
+
+template <uint8_t base, typename T, typename CharT>
+constexpr CharT* uintToStr(CharT* buf, T v, uint8_t min_width) noexcept
+{
+    static_assert(std::is_unsigned_v<T>);
+    uint8_t i = 0;
+    do
+    {
+        if constexpr (std::popcount(base) == 1)
+        {
+            constexpr auto shift = std::countr_zero(base);
+            constexpr auto mask = (1 << shift) - 1;
+            buf[i] = detail::singleIntTable[v & mask];
+            v >>= shift;
+        }
+        else
+        {
+            buf[i] = detail::singleIntTable[v % base];
+            v /= base;
+        }
+        i += 1;
+    } while (v > 0);
+    auto end = buf + std::max(i, min_width);
+    std::fill(buf + i, end, '0');
+    std::reverse(buf, end);
+    return end;
+}
+
+template <uint8_t base, std::integral T, typename CharT>
+constexpr CharT* intToStr(CharT* buf, T v, uint8_t min_width) noexcept
+{
+    if constexpr (std::is_signed_v<T>)
+    {
+        if (v < 0)
+        {
+            *(buf++) = '-';
+            v = -v;
+        }
+    }
+    return uintToStr<base>(buf, std::make_unsigned_t<T>(v), min_width);
+}
+
+} // namespace detail
+
+template <uint8_t base, std::integral T>
+struct IntToStr
+{
+    static_assert(base > 1 && base <= detail::maxBase);
+
+    static inline constexpr size_t buf_size = []() {
+        T v = std::numeric_limits<T>::max();
+        uint8_t i = 0;
+        for (; v != 0; ++i)
+        {
+            v /= base;
+        }
+        return i + std::is_signed_v<T>;
+    }();
+
+    template <typename CharT>
+    constexpr CharT* operator()(CharT* buf, T v,
+                                uint8_t min_width = 0) const noexcept
+    {
+        using ptr_t =
+            std::conditional_t<std::is_signed_v<T>, intptr_t, uintptr_t>;
+        return detail::intToStr<
+            base, std::conditional_t<sizeof(T) <= sizeof(ptr_t), ptr_t, T>>(
+            buf, v, min_width);
+    }
+};
+
+template <std::integral T>
+struct ToStr<T> : IntToStr<10, T>
+{
+    using type = T;
+};
+
+} // namespace stdplus
diff --git a/src/meson.build b/src/meson.build
index 93d68f3..6d17d3d 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -54,6 +54,7 @@
   'net/addr/ip.cpp',
   'net/addr/subnet.cpp',
   'numeric/endian.cpp',
+  'numeric/str.cpp',
   'pinned.cpp',
   'raw.cpp',
   'signal.cpp',
diff --git a/src/numeric/str.cpp b/src/numeric/str.cpp
new file mode 100644
index 0000000..7c3ac13
--- /dev/null
+++ b/src/numeric/str.cpp
@@ -0,0 +1,7 @@
+#include <stdplus/numeric/str.hpp>
+
+namespace stdplus::detail
+{
+template char* uintToStr<16>(char*, uintptr_t, uint8_t) noexcept;
+template char* uintToStr<10>(char*, uintptr_t, uint8_t) noexcept;
+} // namespace stdplus::detail
diff --git a/test/meson.build b/test/meson.build
index 1239296..fd62657 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -10,6 +10,7 @@
   'net/addr/ip': [stdplus_dep, gtest_main_dep],
   'net/addr/subnet': [stdplus_dep, gtest_main_dep],
   'numeric/endian': [stdplus_dep, gtest_main_dep],
+  'numeric/str': [stdplus_dep, gtest_main_dep],
   'pinned': [stdplus_dep, gtest_main_dep],
   'raw': [stdplus_dep, gmock_dep, gtest_main_dep],
   'signal': [stdplus_dep, gtest_main_dep],
diff --git a/test/numeric/str.cpp b/test/numeric/str.cpp
new file mode 100644
index 0000000..5646045
--- /dev/null
+++ b/test/numeric/str.cpp
@@ -0,0 +1,103 @@
+#include <stdplus/numeric/str.hpp>
+
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+namespace stdplus
+{
+
+TEST(IntToStr, Uint8_10)
+{
+    IntToStr<10, uint8_t> enc;
+    static_assert(enc.buf_size == 3);
+    char buf[enc.buf_size];
+    EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+    EXPECT_EQ("42", std::string_view(buf, enc(buf, 42)));
+    EXPECT_EQ("255", std::string_view(buf, enc(buf, 255)));
+    EXPECT_EQ("000", std::string_view(buf, enc(buf, 0, 3)));
+    EXPECT_EQ("255", std::string_view(buf, enc(buf, 255, 3)));
+}
+
+TEST(IntToStr, Int8_10)
+{
+    IntToStr<10, int8_t> enc;
+    static_assert(enc.buf_size == 4);
+    char buf[enc.buf_size];
+    EXPECT_EQ("42", std::string_view(buf, enc(buf, 42)));
+    EXPECT_EQ("-127", std::string_view(buf, enc(buf, -127)));
+}
+
+TEST(IntToStr, Uint16_10)
+{
+    IntToStr<10, uint16_t> enc;
+    static_assert(enc.buf_size == 5);
+    char buf[enc.buf_size];
+    EXPECT_EQ("55255", std::string_view(buf, enc(buf, 55255, 3)));
+}
+
+TEST(IntToStr, Uint32_10)
+{
+    IntToStr<10, uint32_t> enc;
+    static_assert(enc.buf_size == 10);
+    char buf[enc.buf_size];
+    EXPECT_EQ("55255", std::string_view(buf, enc(buf, 55255, 3)));
+    EXPECT_EQ("055255", std::string_view(buf, enc(buf, 55255, 6)));
+    EXPECT_EQ("255255", std::string_view(buf, enc(buf, 255255, 3)));
+}
+
+TEST(IntToStr, Uint8_16)
+{
+    IntToStr<16, uint8_t> enc;
+    static_assert(enc.buf_size == 2);
+    char buf[enc.buf_size];
+    EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+    EXPECT_EQ("2a", std::string_view(buf, enc(buf, 42)));
+    EXPECT_EQ("ff", std::string_view(buf, enc(buf, 255)));
+    EXPECT_EQ("00", std::string_view(buf, enc(buf, 0, 2)));
+    EXPECT_EQ("02", std::string_view(buf, enc(buf, 2, 2)));
+    EXPECT_EQ("ff", std::string_view(buf, enc(buf, 255, 2)));
+}
+
+TEST(IntToStr, Uint8_8)
+{
+    IntToStr<8, uint8_t> enc;
+    static_assert(enc.buf_size == 3);
+    char buf[enc.buf_size];
+    EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+    EXPECT_EQ("7", std::string_view(buf, enc(buf, 7)));
+    EXPECT_EQ("10", std::string_view(buf, enc(buf, 8)));
+    EXPECT_EQ("377", std::string_view(buf, enc(buf, 255)));
+}
+
+TEST(IntToStr, Uint8_11)
+{
+    IntToStr<11, uint8_t> enc;
+    static_assert(enc.buf_size == 3);
+    char buf[enc.buf_size];
+    EXPECT_EQ("0", std::string_view(buf, enc(buf, 0)));
+    EXPECT_EQ("39", std::string_view(buf, enc(buf, 42)));
+    EXPECT_EQ("212", std::string_view(buf, enc(buf, 255)));
+}
+
+TEST(ToString, Int)
+{
+    EXPECT_EQ("10", stdplus::toStr(size_t{10}));
+    EXPECT_EQ(L"10", stdplus::toBasicStr<wchar_t>(size_t{10}));
+    EXPECT_EQ("-10", stdplus::toStr(ssize_t{-10}));
+    EXPECT_EQ(L"-10", stdplus::toBasicStr<wchar_t>(ssize_t{-10}));
+}
+
+TEST(ToString, perf)
+{
+    GTEST_SKIP();
+    IntToStr<16, size_t> enc;
+    char buf[enc.buf_size];
+    for (size_t i = 0; i < 100000000; ++i)
+    {
+        enc(buf, i);
+    }
+    EXPECT_TRUE(false);
+}
+
+} // namespace stdplus