diff --git a/include/ircd/lex_cast.h b/include/ircd/lex_cast.h
index 36092786c..cce007fe6 100644
--- a/include/ircd/lex_cast.h
+++ b/include/ircd/lex_cast.h
@@ -18,22 +18,31 @@ namespace ircd
 {
 	IRCD_EXCEPTION_HIDENAME(ircd::error, bad_lex_cast)
 
+	// Test if lex_cast will succeed
 	template<class T> bool lex_castable(const string_view &) noexcept = delete;
 
+	// Convert from ascii to integral
 	template<class T> T lex_cast(std::string &);
 	template<class T> T lex_cast(const std::string &);
 	template<class T> T lex_cast(const std::string_view &);
 	template<class T> T lex_cast(const string_view &);
 
-	// User supplied destination buffer
+	// Convert from integral to ascii (user supplied destination buffer)
 	template<class T> string_view lex_cast(T, const mutable_buffer &buf);
 
-	// Circular static thread_local buffer
-	extern const size_t LEX_CAST_BUFS;
-	extern const size_t LEX_CAST_BUFSIZE;
+	// Convert from integral to ascii (circular internal thread_local buffer)
 	template<class T> string_view lex_cast(const T &t);
 }
 
+// Internal convenience ring buffer related
+namespace ircd
+{
+	constexpr size_t LEX_CAST_BUFS {256}, LEX_CAST_BUFSIZE {64};
+	extern thread_local char lex_cast_buf[LEX_CAST_BUFS][LEX_CAST_BUFSIZE];
+	extern thread_local uint8_t lex_cast_buf_head;
+}
+
+// Explicit linkages
 namespace ircd
 {
 	template<> bool lex_castable<std::string>(const string_view &) noexcept;       // stub always true
@@ -113,7 +122,7 @@ template<class T>
 inline ircd::string_view
 ircd::lex_cast(const T &t)
 {
-	return lex_cast<T>(t, null_buffer);
+	return lex_cast<T>(t, lex_cast_buf[lex_cast_buf_head++]);
 }
 
 /// Conversion to an std::string creates a copy when the input is a
diff --git a/ircd/Makefile.am b/ircd/Makefile.am
index 9efb5aeeb..ea8edceaa 100644
--- a/ircd/Makefile.am
+++ b/ircd/Makefile.am
@@ -283,7 +283,8 @@ js.lo:                AM_CPPFLAGS := @JS_CPPFLAGS@ ${AM_CPPFLAGS}
 endif
 json.lo:              AM_CPPFLAGS := ${SPIRIT_UNIT_CPPFLAGS} ${AM_CPPFLAGS}
 json.lo:              AM_CXXFLAGS := ${SPIRIT_UNIT_CXXFLAGS} ${AM_CXXFLAGS}
-lex_cast.lo:          AM_CPPFLAGS := @BOOST_CPPFLAGS@ ${AM_CPPFLAGS}
+lex_cast.lo:          AM_CPPFLAGS := ${SPIRIT_UNIT_CPPFLAGS} ${AM_CPPFLAGS}
+lex_cast.lo:          AM_CXXFLAGS := ${SPIRIT_UNIT_CXXFLAGS} ${AM_CXXFLAGS}
 if OPENCL
 cl.lo:                AM_CPPFLAGS := @OPENCL_CPPFLAGS@ ${AM_CPPFLAGS}
 endif
diff --git a/ircd/lex_cast.cc b/ircd/lex_cast.cc
index e6d84f25d..7ff6e0866 100644
--- a/ircd/lex_cast.cc
+++ b/ircd/lex_cast.cc
@@ -8,220 +8,210 @@
 // copyright notice and this permission notice is present in all copies. The
 // full license for this software is available in the LICENSE file.
 
-/// !!! NOTE !!!
-///
-/// Many functions implemented here need to be replaced with karma generators
-/// similar to ircd::fmt. Both the boost and std lexical conversions are an
-/// order of magnitude slower than the formal generators. Some tokenizations
-/// can also be replaced.
-///
-
-#include <boost/lexical_cast.hpp>
-
-decltype(ircd::LEX_CAST_BUFS)
-ircd::LEX_CAST_BUFS
+namespace ircd::lex
 {
-	64 // plenty
-};
+	struct to_float_policy;
+	struct to_double_policy;
+	struct to_long_double_policy;
 
-decltype(ircd::LEX_CAST_BUFSIZE)
-ircd::LEX_CAST_BUFSIZE
-{
-	64
-};
+	struct from_float_policy;
+	struct from_double_policy;
+	struct from_long_double_policy;
 
-namespace ircd
-{
-	/// This is a static "ring buffer" to simplify a majority of lex_cast uses.
-	/// If the lex_cast has binary input and string output, and no user buffer
-	/// is supplied, the next buffer here will be used instead. The returned
-	/// string_view of data from this buffer is only valid for several more
-	/// calls to lex_cast before it is overwritten.
-	thread_local char lex_cast_buf[LEX_CAST_BUFS][LEX_CAST_BUFSIZE];
-	thread_local uint lex_cast_cur;
+	template<class T,
+	         class... A>
+	using rule_to = spirit::qi::rule<const char *, T, A...>
+	__attribute__((visibility("internal")));
 
-	[[noreturn]] static void throw_bad_lex_cast(const boost::bad_lexical_cast &, const std::type_info &);
-	template<size_t N, class T> static string_view _lex_cast(const T &i, mutable_buffer buf);
-	template<class T> static T _lex_cast(const string_view &s);
+	template<class T,
+	         class... A>
+	using rule_from = spirit::karma::rule<char *, T, A...>
+	__attribute__((visibility("internal")));
+
+	template<class T,
+	         class rule,
+	         class exception>
+	[[noreturn]]
+	static void throw_error(const rule &, const exception &e);
+
+	template<class T,
+	         const rule_to<T> &r>
+	static bool test(const string_view &) noexcept;
+
+	template<class T,
+	         const rule_to<T> &r>
+	static T cast(const string_view &);
+
+	template<class T,
+	         const rule_from<T()> &r>
+	static string_view cast(const mutable_buffer &, T);
+
+	#pragma GCC visibility push(internal)
+	extern const rule_to<bool> to_bool;
+	extern const rule_to<int8_t> to_int8_t;
+	extern const rule_to<uint8_t> to_uint8_t;
+	extern const rule_to<short> to_short;
+	extern const rule_to<ushort> to_ushort;
+	extern const rule_to<int> to_int;
+	extern const rule_to<uint> to_uint;
+	extern const rule_to<long> to_long;
+	extern const rule_to<ulong> to_ulong;
+	extern const rule_to<float> to_float;
+	extern const rule_to<double> to_double;
+	extern const rule_to<long double> to_long_double;
+	#pragma GCC visibility pop
+
+	#pragma GCC visibility push(internal)
+	extern const rule_from<bool()> from_bool;
+	extern const rule_from<int8_t()> from_int8_t;
+	extern const rule_from<uint8_t()> from_uint8_t;
+	extern const rule_from<short()> from_short;
+	extern const rule_from<ushort()> from_ushort;
+	extern const rule_from<int()> from_int;
+	extern const rule_from<uint()> from_uint;
+	extern const rule_from<long()> from_long;
+	extern const rule_from<ulong()> from_ulong;
+	extern const rule_from<float()> from_float;
+	extern const rule_from<double()> from_double;
+	extern const rule_from<long double()> from_long_double;
+	#pragma GCC visibility pop
 }
 
-/// Internal template providing conversions from a number to a string;
-/// potentially using the ring buffer if no user buffer is supplied.
-template<size_t N,
-         class T>
-ircd::string_view
-ircd::_lex_cast(const T &i,
-                mutable_buffer buf)
+static_assert
+(
+	ircd::LEX_CAST_BUFS == 256 && sizeof(ircd::lex_cast_buf_head) == 1,
+	"ircd::lex_cast ring buffer integer may not modulate as intended"
+);
+
+/// Indicates the next buffer to be used in the ring. See below.
+thread_local
+decltype(ircd::lex_cast_buf_head)
+ircd::lex_cast_buf_head
+alignas(16);
+
+/// This is a static "ring buffer" to simplify a majority of lex_cast uses.
+/// The returned string_view of data from this buffer is only valid for
+/// several more calls to lex_cast before it is overwritten.
+thread_local
+decltype(ircd::lex_cast_buf)
+ircd::lex_cast_buf
+alignas(64);
+
+template<class T,
+         const ircd::lex::rule_from<T()> &rule>
+[[gnu::always_inline]]
+inline ircd::string_view
+ircd::lex::cast(const mutable_buffer &out,
+                T in)
 try
 {
-	using array = std::array<char, N>;
-
-	if(!buf)
+	constexpr bool truncation
 	{
-		buf = lex_cast_buf[lex_cast_cur++];
-		lex_cast_cur %= LEX_CAST_BUFS;
-	}
+		false
+	};
 
-	assert(size(buf) >= N);
-	auto &a(*reinterpret_cast<array *>(data(buf)));
-	a = boost::lexical_cast<array>(i);
-	return { data(buf), strnlen(data(buf), size(buf)) };
-}
-catch(const boost::bad_lexical_cast &e)
-{
-	throw_bad_lex_cast(e, typeid(T));
-}
-
-/// Internal template providing conversions from a string to a number;
-/// the native object is returned directly; no ring buffer is consumed.
-template<class T>
-T
-ircd::_lex_cast(const string_view &s)
-try
-{
-	return boost::lexical_cast<T>(data(s), size(s));
-}
-catch(const boost::bad_lexical_cast &e)
-{
-	throw_bad_lex_cast(e, typeid(T));
-}
-
-void
-ircd::throw_bad_lex_cast(const boost::bad_lexical_cast &e,
-                         const std::type_info &t)
-{
-	throw ircd::bad_lex_cast
+	mutable_buffer buf
 	{
-		"%s: %s", e.what(), demangle(t.name())
+		out
+	};
+
+	const bool pass
+	{
+		ircd::generate<truncation>
+		(
+			buf, rule | spirit::eps, in
+		)
+	};
+
+	assert(pass);
+	return string_view
+	{
+		data(out), data(buf)
 	};
 }
+catch(const std::exception &e)
+{
+	throw_error<T>(rule, e);
+	__builtin_unreachable();
+}
+
+template<class T,
+         const ircd::lex::rule_to<T> &rule>
+[[gnu::always_inline]]
+inline T
+ircd::lex::cast(const string_view &s)
+try
+{
+	T ret;
+	const char
+	*start(begin(s)),
+	*const stop(end(s));
+	const bool pass
+	{
+		ircd::parse(start, stop, spirit::expect[rule], ret)
+	};
+
+	assert(pass);
+	return ret;
+}
+catch(const std::exception &e)
+{
+	throw_error<T>(rule, e);
+	__builtin_unreachable();
+}
+
+template<class T,
+         const ircd::lex::rule_to<T> &rule>
+[[gnu::always_inline]]
+inline bool
+ircd::lex::test(const string_view &s)
+noexcept
+{
+	const char
+	*start(begin(s)),
+	*const stop(end(s));
+	return ircd::parse(start, stop, &rule);
+}
+
+template<class T,
+         class rule,
+         class exception>
+[[noreturn, gnu::noinline, gnu::cold]]
+void
+ircd::lex::throw_error(const rule &r,
+                       const exception &e)
+{
+	throw bad_lex_cast
+	{
+		"%s :%s",
+		e.what(),
+		demangle(typeid(T).name())
+	};
+}
+
+//
+// bool
+//
+
+decltype(ircd::lex::to_bool)
+ircd::lex::to_bool
+{
+	spirit::qi::bool_
+	,"boolean"
+};
+
+decltype(ircd::lex::from_bool)
+ircd::lex::from_bool
+{
+	spirit::karma::bool_
+	,"boolean"
+};
 
 template<> ircd::string_view
 ircd::lex_cast(bool i,
                const mutable_buffer &buf)
 {
-	static const size_t MAX(8);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(int8_t i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(8);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(uint8_t i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(8);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(short i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(8);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(ushort i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(8);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(int i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(16);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(uint i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(16);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(long i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(32);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(ulong i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(32);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(float i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(double i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(long double i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i, buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(nanoseconds i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i.count(), buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(microseconds i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i.count(), buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(milliseconds i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i.count(), buf);
-}
-
-template<> ircd::string_view
-ircd::lex_cast(seconds i,
-               const mutable_buffer &buf)
-{
-	static const size_t MAX(64);
-	return _lex_cast<MAX>(i.count(), buf);
+	return lex::cast<bool, lex::from_bool>(buf, i);
 }
 
 template<> bool
@@ -229,223 +219,589 @@ ircd::lex_cast(const string_view &s)
 {
 	return s == "true"? true:
 	       s == "false"? false:
-	       _lex_cast<bool>(s);
-}
-
-template<> int8_t
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<char>(s);
-}
-
-template<> uint8_t
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<unsigned char>(s);
-}
-
-template<> short
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<short>(s);
-}
-
-template<> unsigned short
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<unsigned short>(s);
-}
-
-template<> int
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<int>(s);
-}
-
-template<> unsigned int
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<unsigned int>(s);
-}
-
-template<> long
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<long>(s);
-}
-
-template<> unsigned long
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<unsigned long>(s);
-}
-
-template<> float
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<float>(s);
-}
-
-template<> double
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<double>(s);
-}
-
-template<> long double
-ircd::lex_cast(const string_view &s)
-{
-	return _lex_cast<long double>(s);
-}
-
-template<> ircd::nanoseconds
-ircd::lex_cast(const string_view &s)
-{
-	return std::chrono::duration<time_t, std::ratio<1L, 1000000000L>>(_lex_cast<time_t>(s));
-}
-
-template<> ircd::microseconds
-ircd::lex_cast(const string_view &s)
-{
-	return std::chrono::duration<time_t, std::ratio<1L, 1000000L>>(_lex_cast<time_t>(s));
-}
-
-template<> ircd::milliseconds
-ircd::lex_cast(const string_view &s)
-{
-	return std::chrono::duration<time_t, std::ratio<1L, 1000L>>(_lex_cast<time_t>(s));
-}
-
-template<> ircd::seconds
-ircd::lex_cast(const string_view &s)
-{
-	return std::chrono::duration<time_t, std::ratio<1L, 1L>>(_lex_cast<time_t>(s));
+	       lex::cast<bool, lex::to_bool>(s);
 }
 
 template<> bool
 ircd::lex_castable<bool>(const string_view &s)
 noexcept
 {
-	bool i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<bool, lex::to_bool>(s);
+}
+
+//
+// int8_t
+//
+
+decltype(ircd::lex::to_int8_t)
+ircd::lex::to_int8_t
+{
+	spirit::qi::short_
+	,"signed byte"
+};
+
+decltype(ircd::lex::from_int8_t)
+ircd::lex::from_int8_t
+{
+	spirit::karma::short_
+	,"signed byte"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(int8_t i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<int8_t, lex::from_int8_t>(buf, i);
+}
+
+template<> int8_t
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<int8_t, lex::to_int8_t>(s);
 }
 
 template<> bool
 ircd::lex_castable<int8_t>(const string_view &s)
 noexcept
 {
-	int8_t i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<int8_t, lex::to_int8_t>(s);
+}
+
+//
+// uint8_t
+//
+
+decltype(ircd::lex::to_uint8_t)
+ircd::lex::to_uint8_t
+{
+	spirit::qi::ushort_
+	,"unsigned byte"
+};
+
+decltype(ircd::lex::from_uint8_t)
+ircd::lex::from_uint8_t
+{
+	spirit::karma::ushort_
+	,"unsigned byte"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(uint8_t i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<uint8_t, lex::from_uint8_t>(buf, i);
+}
+
+template<> uint8_t
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<uint8_t, lex::to_uint8_t>(s);
 }
 
 template<> bool
 ircd::lex_castable<uint8_t>(const string_view &s)
 noexcept
 {
-	uint8_t i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<uint8_t, lex::to_uint8_t>(s);
+}
+
+//
+// short
+//
+
+decltype(ircd::lex::to_short)
+ircd::lex::to_short
+{
+	spirit::qi::short_
+	,"signed short integer"
+};
+
+decltype(ircd::lex::from_short)
+ircd::lex::from_short
+{
+	spirit::karma::short_
+	,"signed short integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(short i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<short, lex::from_short>(buf, i);
+}
+
+template<> short
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<short, lex::to_short>(s);
 }
 
 template<> bool
 ircd::lex_castable<short>(const string_view &s)
 noexcept
 {
-	short i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<short, lex::to_short>(s);
+}
+
+//
+// ushort
+//
+
+decltype(ircd::lex::to_ushort)
+ircd::lex::to_ushort
+{
+	spirit::qi::ushort_
+	,"unsigned short integer"
+};
+
+decltype(ircd::lex::from_ushort)
+ircd::lex::from_ushort
+{
+	spirit::karma::ushort_
+	,"unsigned short integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(ushort i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<ushort, lex::from_ushort>(buf, i);
+}
+
+template<> ushort
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<ushort, lex::to_ushort>(s);
 }
 
 template<> bool
 ircd::lex_castable<ushort>(const string_view &s)
 noexcept
 {
-	ushort i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<ushort, lex::to_ushort>(s);
+}
+
+//
+// signed
+//
+
+decltype(ircd::lex::to_int)
+ircd::lex::to_int
+{
+	spirit::qi::int_
+	,"signed integer"
+};
+
+decltype(ircd::lex::from_int)
+ircd::lex::from_int
+{
+	spirit::karma::int_
+	,"signed integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(int i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<int, lex::from_int>(buf, i);
+}
+
+template<> int
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<int, lex::to_int>(s);
 }
 
 template<> bool
 ircd::lex_castable<int>(const string_view &s)
 noexcept
 {
-	int i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<int, lex::to_int>(s);
+}
+
+//
+// unsigned
+//
+
+decltype(ircd::lex::to_uint)
+ircd::lex::to_uint
+{
+	spirit::qi::uint_
+	,"unsigned integer"
+};
+
+decltype(ircd::lex::from_uint)
+ircd::lex::from_uint
+{
+	spirit::karma::uint_
+	,"unsigned integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(uint i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<uint, lex::from_uint>(buf, i);
+}
+
+template<> unsigned int
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<uint, lex::to_uint>(s);
 }
 
 template<> bool
-ircd::lex_castable<unsigned int>(const string_view &s)
+ircd::lex_castable<uint>(const string_view &s)
 noexcept
 {
-	unsigned int i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<uint, lex::to_uint>(s);
+}
+
+//
+// long
+//
+
+decltype(ircd::lex::to_long)
+ircd::lex::to_long
+{
+	spirit::qi::long_
+	,"long integer"
+};
+
+decltype(ircd::lex::from_long)
+ircd::lex::from_long
+{
+	spirit::karma::long_
+	,"long integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(long i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<long, lex::from_long>(buf, i);
+}
+
+template<> long
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<long, lex::to_long>(s);
 }
 
 template<> bool
 ircd::lex_castable<long>(const string_view &s)
 noexcept
 {
-	long i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<long, lex::to_long>(s);
+}
+
+//
+// ulong
+//
+
+decltype(ircd::lex::to_ulong)
+ircd::lex::to_ulong
+{
+	spirit::qi::ulong_
+	,"long unsigned integer"
+};
+
+decltype(ircd::lex::from_ulong)
+ircd::lex::from_ulong
+{
+	spirit::karma::ulong_
+	,"long unsigned integer"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(ulong i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<ulong, lex::from_ulong>(buf, i);
+}
+
+template<> unsigned long
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<ulong, lex::to_ulong>(s);
 }
 
 template<> bool
-ircd::lex_castable<unsigned long>(const string_view &s)
+ircd::lex_castable<ulong>(const string_view &s)
 noexcept
 {
-	unsigned long i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<ulong, lex::to_ulong>(s);
+}
+
+//
+// float
+//
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::to_float_policy
+:spirit::qi::real_policies<float>
+{
+	static const bool
+	allow_leading_dot   { false },
+	allow_trailing_dot  { false },
+	expect_dot          { false };
+};
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::from_float_policy
+:spirit::karma::real_policies<float>
+{
+
+};
+
+decltype(ircd::lex::to_float)
+ircd::lex::to_float
+{
+	spirit::qi::real_parser<float, to_float_policy>{}
+	,"single floating point precision"
+};
+
+decltype(ircd::lex::from_float)
+ircd::lex::from_float
+{
+	spirit::karma::real_generator<float, from_float_policy>{}
+	,"single floating point precision"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(float i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<float, lex::from_float>(buf, i);
+}
+
+template<> float
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<float, lex::to_float>(s);
 }
 
 template<> bool
 ircd::lex_castable<float>(const string_view &s)
 noexcept
 {
-	float i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<float, lex::to_float>(s);
+}
+
+//
+// double
+//
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::to_double_policy
+:spirit::qi::real_policies<double>
+{
+	static const bool
+	allow_leading_dot   { false },
+	allow_trailing_dot  { false },
+	expect_dot          { false };
+};
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::from_double_policy
+:spirit::karma::real_policies<double>
+{
+
+};
+
+decltype(ircd::lex::to_double)
+ircd::lex::to_double
+{
+	spirit::qi::real_parser<double, to_double_policy>{}
+	,"double floating point precision"
+};
+
+decltype(ircd::lex::from_double)
+ircd::lex::from_double
+{
+	spirit::karma::real_generator<double, from_double_policy>{}
+	,"double floating point precision"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(double i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<double, lex::from_double>(buf, i);
+}
+
+template<> double
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<double, lex::to_double>(s);
 }
 
 template<> bool
 ircd::lex_castable<double>(const string_view &s)
 noexcept
 {
-	double i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<double, lex::to_double>(s);
+}
+
+//
+// long double
+//
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::to_long_double_policy
+:spirit::qi::real_policies<long double>
+{
+	static const bool
+	allow_leading_dot   { false },
+	allow_trailing_dot  { false },
+	expect_dot          { false };
+};
+
+struct [[gnu::visibility("internal")]]
+ircd::lex::from_long_double_policy
+:spirit::karma::real_policies<long double>
+{
+
+};
+
+decltype(ircd::lex::to_long_double)
+ircd::lex::to_long_double
+{
+	spirit::qi::real_parser<long double, to_long_double_policy>{}
+	,"long double floating point precision"
+};
+
+decltype(ircd::lex::from_long_double)
+ircd::lex::from_long_double
+{
+	spirit::karma::real_generator<long double, from_long_double_policy>{}
+	,"long double floating point precision"
+};
+
+template<> ircd::string_view
+ircd::lex_cast(long double i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<long double, lex::from_long_double>(buf, i);
+}
+
+template<> long double
+ircd::lex_cast(const string_view &s)
+{
+	return lex::cast<long double, lex::to_long_double>(s);
 }
 
 template<> bool
 ircd::lex_castable<long double>(const string_view &s)
 noexcept
 {
-	long double i;
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<long double, lex::to_long_double>(s);
 }
 
-template<> bool
-ircd::lex_castable<ircd::nanoseconds>(const string_view &s)
-noexcept
+//
+// seconds
+//
+
+template<> ircd::string_view
+ircd::lex_cast(seconds i,
+               const mutable_buffer &buf)
 {
-	time_t i; //TODO: XXX
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::cast<time_t, lex::from_long>(buf, i.count());
 }
 
-template<> bool
-ircd::lex_castable<ircd::microseconds>(const string_view &s)
-noexcept
+template<> ircd::seconds
+ircd::lex_cast(const string_view &s)
 {
-	time_t i; //TODO: XXX
-	return boost::conversion::try_lexical_convert(s, i);
-}
-
-template<> bool
-ircd::lex_castable<ircd::milliseconds>(const string_view &s)
-noexcept
-{
-	time_t i; //TODO: XXX
-	return boost::conversion::try_lexical_convert(s, i);
+	return std::chrono::duration<time_t, std::ratio<1L, 1L>>
+	(
+		lex::cast<time_t, lex::to_long>(s)
+	);
 }
 
 template<> bool
 ircd::lex_castable<ircd::seconds>(const string_view &s)
 noexcept
 {
-	time_t i; //TODO: XXX
-	return boost::conversion::try_lexical_convert(s, i);
+	return lex::test<time_t, lex::to_long>(s);
+}
+
+//
+// milliseconds
+//
+
+template<> ircd::string_view
+ircd::lex_cast(milliseconds i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<time_t, lex::from_long>(buf, i.count());
+}
+
+template<> ircd::milliseconds
+ircd::lex_cast(const string_view &s)
+{
+	return std::chrono::duration<time_t, std::ratio<1L, 1000L>>
+	(
+		lex::cast<time_t, lex::to_long>(s)
+	);
+}
+
+template<> bool
+ircd::lex_castable<ircd::milliseconds>(const string_view &s)
+noexcept
+{
+	return lex::test<time_t, lex::to_long>(s);
+}
+
+//
+// microseconds
+//
+
+template<> ircd::string_view
+ircd::lex_cast(microseconds i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<time_t, lex::from_long>(buf, i.count());
+}
+
+template<> ircd::microseconds
+ircd::lex_cast(const string_view &s)
+{
+	return std::chrono::duration<time_t, std::ratio<1L, 1000000L>>
+	(
+		lex::cast<time_t, lex::to_long>(s)
+	);
+}
+
+template<> bool
+ircd::lex_castable<ircd::microseconds>(const string_view &s)
+noexcept
+{
+	return lex::test<time_t, lex::to_long>(s);
+}
+
+//
+// nanoseconds
+//
+
+template<> ircd::string_view
+ircd::lex_cast(nanoseconds i,
+               const mutable_buffer &buf)
+{
+	return lex::cast<time_t, lex::from_long>(buf, i.count());
+}
+
+template<> ircd::nanoseconds
+ircd::lex_cast(const string_view &s)
+{
+	return std::chrono::duration<time_t, std::ratio<1L, 1000000000L>>
+	(
+		lex::cast<time_t, lex::to_long>(s)
+	);
+}
+
+template<> bool
+ircd::lex_castable<ircd::nanoseconds>(const string_view &s)
+noexcept
+{
+	return lex::test<time_t, lex::to_long>(s);
 }