diff --git a/rjp++/include/array.hpp b/rjp++/include/array.hpp
index f4be53b..d0c8e97 100644
--- a/rjp++/include/array.hpp
+++ b/rjp++/include/array.hpp
@@ -91,7 +91,7 @@ namespace rjp{
 		string_val add(const RJP_string&);
 		string_val add(RJP_string&&);
 		string_val add(const char*, RJP_index len = 0);
-		string_val add(const rexy::string_base&);
+		string_val add(const rexy::string_base<char>&);
 		string_val add(string&&);
 
 		value& remove(value& val);
diff --git a/rjp++/include/member.hpp b/rjp++/include/member.hpp
index fff1b46..81231b1 100644
--- a/rjp++/include/member.hpp
+++ b/rjp++/include/member.hpp
@@ -52,8 +52,8 @@ namespace rjp{
 		member& operator=(const member&) = default;
 		member& operator=(member&&) = default;
 
-		rexy::static_string key(void)const{
-			return rexy::static_string(member_key(this->m_value)->value, member_key(this->m_value)->length);
+		rexy::static_string<char> key(void)const{
+			return rexy::static_string<char>(member_key(this->m_value)->value, member_key(this->m_value)->length);
 		}
 		string steal_key(void){
 			return string(this->m_value);
@@ -76,8 +76,8 @@ namespace rjp{
 		member& operator=(const member&) = default;
 		member& operator=(member&&) = default;
 
-		rexy::static_string key(void)const{
-			return rexy::static_string(member_key(m_value)->value, member_key(m_value)->length);
+		rexy::static_string<char> key(void)const{
+			return rexy::static_string<char>(member_key(m_value)->value, member_key(m_value)->length);
 		}
 		string steal_key(void){
 			return string(m_value);
diff --git a/rjp++/include/object.hpp b/rjp++/include/object.hpp
index 23b80d7..48b4d4c 100644
--- a/rjp++/include/object.hpp
+++ b/rjp++/include/object.hpp
@@ -73,13 +73,13 @@ namespace rjp{
 		object& operator=(object&&) = default;
 
 		template<class Val>
-		member<std::decay_t<Val>> add(const rexy::string_base& key, typename std::decay_t<Val>::underlying_type t){
+		member<std::decay_t<Val>> add(const rexy::string_base<char>& key, typename std::decay_t<Val>::underlying_type t){
 			RJP_value* newmem = add_member_impl(key);
 			detail::set_to_underlying<std::decay_t<Val>>(newmem, t);
 			return create_unmanaged(newmem);
 		}
 		template<class Val = null>
-		member<std::decay_t<Val>> add(const rexy::string_base& key){
+		member<std::decay_t<Val>> add(const rexy::string_base<char>& key){
 			RJP_value* newmem = add_member_impl(key);
 			if constexpr(std::is_same<std::decay_t<Val>,rjp::array>::value)
 				set_array_value(newmem);
@@ -91,11 +91,11 @@ namespace rjp{
 				detail::set_to_underlying<std::decay_t<Val>>(newmem, 0);
 			return create_unmanaged(newmem);
 		}
-		member<string_val> add(const rexy::string_base& key, const RJP_string&);
-		member<string_val> add(const rexy::string_base& key, RJP_string&&);
-		member<string_val> add(const rexy::string_base& key, const char*, RJP_index len = 0);
-		member<string_val> add(const rexy::string_base& key, const rexy::string_base&);
-		member<string_val> add(const rexy::string_base& key, string&&);
+		member<string_val> add(const rexy::string_base<char>& key, const RJP_string&);
+		member<string_val> add(const rexy::string_base<char>& key, RJP_string&&);
+		member<string_val> add(const rexy::string_base<char>& key, const char*, RJP_index len = 0);
+		member<string_val> add(const rexy::string_base<char>& key, const rexy::string_base<char>&);
+		member<string_val> add(const rexy::string_base<char>& key, string&&);
 
 		template<class Val>
 		member<std::decay_t<Val>> add(string&& key, typename std::decay_t<Val>::underlying_type t){
@@ -119,13 +119,13 @@ namespace rjp{
 		member<string_val> add(string&& key, const RJP_string&);
 		member<string_val> add(string&& key, RJP_string&&);
 		member<string_val> add(string&& key, const char*, RJP_index len = 0);
-		member<string_val> add(string&& key, const rexy::string_base&);
+		member<string_val> add(string&& key, const rexy::string_base<char>&);
 		member<string_val> add(string&& key, string&&);
 
-		value remove(const rexy::string_base& key);
+		value remove(const rexy::string_base<char>& key);
 		value& remove(value& val);
 
-		void destroy(const rexy::string_base& key);
+		void destroy(const rexy::string_base<char>& key);
 		void destroy(value&& val);
 
 		bool has_child(const value&);
@@ -134,11 +134,11 @@ namespace rjp{
 		const_iterator begin(void)const;
 		iterator end(void)const;
 
-		value search(const rexy::string_base& key)const;
+		value search(const rexy::string_base<char>& key)const;
 
 	private:
-		RJP_value* add_member_impl(const rexy::string_base& key);
-		RJP_value* add_member_impl(rexy::string_base&& key);
+		RJP_value* add_member_impl(const rexy::string_base<char>& key);
+		RJP_value* add_member_impl(rexy::string_base<char>&& key);
 	};
 
 }
diff --git a/rjp++/include/parse.hpp b/rjp++/include/parse.hpp
index 181ba43..481fca7 100644
--- a/rjp++/include/parse.hpp
+++ b/rjp++/include/parse.hpp
@@ -49,7 +49,7 @@ namespace rjp{
 	};
 
 	string to_json(const value& val, int format = RJP_FORMAT_PRETTY);
-	parse_res parse_json(const rexy::string_base& str, RJP_parse_flag = RJP_PARSE_NO_EXT);
+	parse_res parse_json(const rexy::string_base<char>& str, RJP_parse_flag = RJP_PARSE_NO_EXT);
 	parse_res parse_json(const char* str, RJP_parse_flag = RJP_PARSE_NO_EXT);
 	namespace detail{
 		template<int... Indexes>
diff --git a/rjp++/include/string.hpp b/rjp++/include/string.hpp
index 4b7f8d5..f114249 100644
--- a/rjp++/include/string.hpp
+++ b/rjp++/include/string.hpp
@@ -36,7 +36,7 @@ namespace rjp{
 		};
 	}
 
-	class string : public rexy::basic_string<detail::allocator>
+	class string : public rexy::basic_string<char,detail::allocator>
 	{
 	public:
 		string(const string&) = default;
@@ -44,13 +44,13 @@ namespace rjp{
 		string& operator=(const string&) = default;
 		string& operator=(string&&) = default;
 
-		using rexy::basic_string<detail::allocator>::basic_string;
+		using rexy::basic_string<char,detail::allocator>::basic_string;
 		string(RJP_value* r);
-		using rexy::basic_string<detail::allocator>::operator=;
+		using rexy::basic_string<char,detail::allocator>::operator=;
 		string& operator=(RJP_value* r);
 	};
 
-	string escape(const rexy::string_base& str);
+	string escape(const rexy::string_base<char>& str);
 	string escape(const char* c);
 
 }
diff --git a/rjp++/include/string_val.hpp b/rjp++/include/string_val.hpp
index 99ee5b6..aca42db 100644
--- a/rjp++/include/string_val.hpp
+++ b/rjp++/include/string_val.hpp
@@ -32,13 +32,13 @@ namespace rjp{
 		using underlying_type = RJP_string;
 	public:
 		using value::value;
-		string_val(const rexy::string_base& str);
+		string_val(const rexy::string_base<char>& str);
 		string_val(string&& str);
 		string_val(void);
 		string_val(const value& val);
 		string_val(value&& val);
-		string_val(const value& val, const rexy::string_base& i);
-		string_val(value&& val, const rexy::string_base& i);
+		string_val(const value& val, const rexy::string_base<char>& i);
+		string_val(value&& val, const rexy::string_base<char>& i);
 		string_val(const value& val, string&& i);
 		string_val(value&& val, string&& i);
 
@@ -48,9 +48,9 @@ namespace rjp{
 		string_val& operator=(const string_val&) = default;
 		string_val& operator=(string_val&&) = default;
 
-		rexy::static_string get(void)const;
+		rexy::static_string<char> get(void)const;
 		string steal(void);
-		void set(const rexy::string_base& str);
+		void set(const rexy::string_base<char>& str);
 		void set(string&& str);
 
 	};
diff --git a/rjp++/include/value.hpp b/rjp++/include/value.hpp
index 897354c..250584d 100644
--- a/rjp++/include/value.hpp
+++ b/rjp++/include/value.hpp
@@ -35,7 +35,7 @@ namespace rjp{
 			vget_proxy(const rjp::value* v);
 			operator int(void)const;
 			operator bool(void)const;
-			operator rexy::static_string(void)const;
+			operator rexy::static_string<char>(void)const;
 			operator double(void)const;
 		};
 	}
diff --git a/rjp++/src/array.cpp b/rjp++/src/array.cpp
index 85adf7e..c1a0c0a 100644
--- a/rjp++/src/array.cpp
+++ b/rjp++/src/array.cpp
@@ -55,7 +55,7 @@ namespace rjp{
 		rjp_set_string(newelem, c, len);
 		return string_val(create_unmanaged(newelem));
 	}
-	string_val array::add(const rexy::string_base& s){
+	string_val array::add(const rexy::string_base<char>& s){
 		return add(s.get(), s.length());
 	}
 	string_val array::add(string&& s){
diff --git a/rjp++/src/object.cpp b/rjp++/src/object.cpp
index 51a6f12..34388f7 100644
--- a/rjp++/src/object.cpp
+++ b/rjp++/src/object.cpp
@@ -39,27 +39,27 @@ namespace rjp{
 		if(rjp_value_type(m_value) != rjp_json_object)
 			rjp_set_object(m_value);
 	}
-	member<string_val> object::add(const rexy::string_base& key, const RJP_string& s){
+	member<string_val> object::add(const rexy::string_base<char>& key, const RJP_string& s){
 		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
 		rjp_set_string(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_base& key, RJP_string&& s){
+	member<string_val> object::add(const rexy::string_base<char>& key, RJP_string&& s){
 		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
 		rjp_set_string_steal(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_base& key, const char* s, RJP_index len){
+	member<string_val> object::add(const rexy::string_base<char>& key, const char* s, RJP_index len){
 		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
 		rjp_set_string(newmem, s, len);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_base& key, const rexy::string_base& s){
+	member<string_val> object::add(const rexy::string_base<char>& key, const rexy::string_base<char>& s){
 		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
 		rjp_set_string(newmem, s.get(), s.length());
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_base& key, string&& s){
+	member<string_val> object::add(const rexy::string_base<char>& key, string&& s){
 		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
 		auto len = s.length();
 		rjp_set_string_steal(newmem, s.release(), len);
@@ -81,7 +81,7 @@ namespace rjp{
 		rjp_set_string(newmem, s, len);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(string&& key, const rexy::string_base& s){
+	member<string_val> object::add(string&& key, const rexy::string_base<char>& s){
 		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
 		rjp_set_string(newmem, s.get(), s.length());
 		return create_unmanaged(newmem);
@@ -93,7 +93,7 @@ namespace rjp{
 		return create_unmanaged(newmem);
 	}
 
-	value object::remove(const rexy::string_base& key){
+	value object::remove(const rexy::string_base<char>& key){
 		RJP_value* removed = rjp_remove_member_by_key(m_value, key.get());
 		return create_managed(removed);
 	}
@@ -103,7 +103,7 @@ namespace rjp{
 		return val;
 	}
 
-	void object::destroy(const rexy::string_base& key){
+	void object::destroy(const rexy::string_base<char>& key){
 		rjp_free_member_by_key(m_value, key.get());
 	}
 	void object::destroy(value&& val){
@@ -122,15 +122,15 @@ namespace rjp{
 	object::iterator object::end(void)const{
 		return iterator();
 	}
-	value object::search(const rexy::string_base& key)const{
+	value object::search(const rexy::string_base<char>& key)const{
 		RJP_value* result = rjp_search_member(m_value, key.get());
 		return create_unmanaged(result);
 	}
 
-	RJP_value* object::add_member_impl(const rexy::string_base& key){
+	RJP_value* object::add_member_impl(const rexy::string_base<char>& key){
 		return rjp_new_member(m_value, key.get(), key.length());
 	}
-	RJP_value* object::add_member_impl(rexy::string_base&& key){
+	RJP_value* object::add_member_impl(rexy::string_base<char>&& key){
 		auto length = key.length();
 		return rjp_new_member_steal_key(m_value, key.release(), length);
 	}
diff --git a/rjp++/src/rjp.cpp b/rjp++/src/rjp.cpp
index a16595f..dd5cff8 100644
--- a/rjp++/src/rjp.cpp
+++ b/rjp++/src/rjp.cpp
@@ -57,7 +57,7 @@ namespace rjp{
 		s.reset(rjp_to_json(val.raw(), format));
 		return s;
 	}
-	parse_res parse_json(const rexy::string_base& str, RJP_parse_flag flags){
+	parse_res parse_json(const rexy::string_base<char>& str, RJP_parse_flag flags){
 		return parse_json(str.get(), flags);
 	}
 	parse_res parse_json(const char* str, RJP_parse_flag flags){
diff --git a/rjp++/src/string.cpp b/rjp++/src/string.cpp
index 0e69bb5..79bac01 100644
--- a/rjp++/src/string.cpp
+++ b/rjp++/src/string.cpp
@@ -24,7 +24,7 @@
 namespace rjp{
 
 	string::string(RJP_value* r):
-		rexy::basic_string<detail::allocator>(rexy::steal(r ? rjp_get_string(r)->value : nullptr),
+		rexy::basic_string<char,detail::allocator>(rexy::steal(r ? rjp_get_string(r)->value : nullptr),
 	                                             r ? rjp_get_string(r)->length : 0,
 	                                             r ? rjp_get_string(r)->length : 0)
 	{
@@ -47,7 +47,7 @@ namespace rjp{
 		return *this;
 	}
 
-	string escape(const rexy::string_base& str){
+	string escape(const rexy::string_base<char>& str){
 		return escape(str.c_str());
 	}
 	string escape(const char* c){
diff --git a/rjp++/src/string_val.cpp b/rjp++/src/string_val.cpp
index 0200931..9016c97 100644
--- a/rjp++/src/string_val.cpp
+++ b/rjp++/src/string_val.cpp
@@ -22,7 +22,7 @@
 
 namespace rjp{
 
-	string_val::string_val(const rexy::string_base& str):
+	string_val::string_val(const rexy::string_base<char>& str):
 		value(rjp_new_string(str.get(), str.length()), true){}
 	string_val::string_val(string&& str):
 		value(rjp_new_string_steal(str.get(), str.length()), true)
@@ -47,12 +47,12 @@ namespace rjp{
 		if(rjp_value_type(m_value) != rjp_json_string)
 			rjp_set_string(m_value, "", 0);
 	}
-	string_val::string_val(const value& val, const rexy::string_base& i):
+	string_val::string_val(const value& val, const rexy::string_base<char>& i):
 		value(val)
 	{
 		rjp_set_string(m_value, i.get(), i.length());
 	}
-	string_val::string_val(value&& val, const rexy::string_base& i):
+	string_val::string_val(value&& val, const rexy::string_base<char>& i):
 		value(std::move(val))
 	{
 		rjp_set_string(m_value, i.get(), i.length());
@@ -70,14 +70,14 @@ namespace rjp{
 		rjp_set_string_steal(m_value, i.release(), length);
 	}
 
-	rexy::static_string string_val::get(void)const{
+	rexy::static_string<char> string_val::get(void)const{
 		const RJP_string* str = rjp_get_cstring(m_value);
-		return rexy::static_string(str->value, str->length);
+		return rexy::static_string<char>(str->value, str->length);
 	}
 	string string_val::steal(void){
 		return string(m_value);
 	}
-	void string_val::set(const rexy::string_base& str){
+	void string_val::set(const rexy::string_base<char>& str){
 		rjp_set_string(m_value, str.get(), str.length());
 	}
 	void string_val::set(string&& str){
diff --git a/rjp++/src/vget_proxy.cpp b/rjp++/src/vget_proxy.cpp
index bf49039..72b66fb 100644
--- a/rjp++/src/vget_proxy.cpp
+++ b/rjp++/src/vget_proxy.cpp
@@ -32,7 +32,7 @@ namespace rjp::detail{
 	vget_proxy::operator bool(void)const{
 		return rjp::cast<const rjp::boolean>(*m_value).get();
 	}
-	vget_proxy::operator rexy::static_string(void)const{
+	vget_proxy::operator rexy::static_string<char>(void)const{
 		return rjp::cast<const rjp::string_val>(*m_value).get();
 	}
 	vget_proxy::operator double(void)const{
diff --git a/rjp++/tests/output.cpp b/rjp++/tests/output.cpp
index 88aac59..35cbe9c 100644
--- a/rjp++/tests/output.cpp
+++ b/rjp++/tests/output.cpp
@@ -123,7 +123,7 @@ rjp::value case_19(void){
 	arr.add<rjp::integer>(5);
 	rjp::object subobj = arr.add<rjp::object>();
 	for(int i = 0;i < 10;++i){
-		subobj.add<rjp::boolean>(rexy::static_string(c), i % 2 == 0);
+		subobj.add<rjp::boolean>(rexy::static_string<char>(c), i % 2 == 0);
 		c[3] += 1;
 	}
 	return rjp::cast<rjp::value&&>(arr);