diff --git a/src/backend.rs b/src/backend.rs
index 3827082..474dd93 100644
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -1,3 +1,8 @@
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+
 #[cfg(feature = "arc")]
 pub(crate) type DefaultStr = crate::backend::ArcStr;
 #[cfg(not(feature = "arc"))]
@@ -8,15 +13,15 @@ pub type BoxedStr = Box<str>;
 static_assertions::assert_eq_size!(DefaultStr, BoxedStr);
 
 /// Cross-thread, O(1) clones
-pub type ArcStr = std::sync::Arc<str>;
+pub type ArcStr = alloc::sync::Arc<str>;
 static_assertions::assert_eq_size!(DefaultStr, ArcStr);
 
 /// O(1) clones
-pub type RcStr = std::rc::Rc<str>;
+pub type RcStr = alloc::rc::Rc<str>;
 static_assertions::assert_eq_size!(DefaultStr, RcStr);
 
 /// Abstract over different type of heap-allocated strings
-pub trait HeapStr: std::fmt::Debug + Clone + private::Sealed {
+pub trait HeapStr: core::fmt::Debug + Clone + private::Sealed {
     fn from_str(other: &str) -> Self;
     fn from_string(other: String) -> Self;
     fn from_boxed_str(other: BoxedStr) -> Self;
diff --git a/src/lib.rs b/src/lib.rs
index 94fdc23..bffbefc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -37,10 +37,13 @@
 //!
 #![cfg_attr(feature = "document-features", doc = document_features::document_features!())]
 #![cfg_attr(not(feature = "unsafe"), forbid(unsafe_code))]
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![warn(clippy::std_instead_of_core)]
+#![warn(clippy::std_instead_of_alloc)]
 
-#[cfg(not(feature = "std"))]
-compile_error!("`std` feature is required; reserved for future `no_std` support");
+#[allow(unused_extern_crates)]
+extern crate alloc;
 
 mod stack;
 mod string;
@@ -60,20 +63,20 @@ mod test {
     fn test_size() {
         println!(
             "String: {}",
-            std::mem::size_of::<crate::string::StdString>()
+            core::mem::size_of::<crate::string::StdString>()
         );
         println!(
             "Box<str>: {}",
-            std::mem::size_of::<crate::backend::DefaultStr>()
+            core::mem::size_of::<crate::backend::DefaultStr>()
         );
         println!(
             "Box<Box<str>>: {}",
-            std::mem::size_of::<Box<crate::backend::DefaultStr>>()
+            core::mem::size_of::<Box<crate::backend::DefaultStr>>()
         );
-        println!("str: {}", std::mem::size_of::<&'static str>());
+        println!("str: {}", core::mem::size_of::<&'static str>());
         println!(
             "Cow: {}",
-            std::mem::size_of::<std::borrow::Cow<'static, str>>()
+            core::mem::size_of::<alloc::borrow::Cow<'static, str>>()
         );
     }
 }
diff --git a/src/stack.rs b/src/stack.rs
index faad13e..76318f7 100644
--- a/src/stack.rs
+++ b/src/stack.rs
@@ -1,4 +1,6 @@
-use std::fmt;
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+use core::fmt;
 
 pub(crate) type Len = u8;
 
@@ -257,7 +259,7 @@ impl<const CAPACITY: usize> Default for StackString<CAPACITY> {
     }
 }
 
-impl<const CAPACITY: usize> std::ops::Deref for StackString<CAPACITY> {
+impl<const CAPACITY: usize> core::ops::Deref for StackString<CAPACITY> {
     type Target = str;
 
     #[inline]
@@ -298,42 +300,42 @@ impl<const CAPACITY: usize> PartialEq<String> for StackString<CAPACITY> {
 
 impl<const CAPACITY: usize> Ord for StackString<CAPACITY> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.as_str().cmp(other.as_str())
     }
 }
 
 impl<const C1: usize, const C2: usize> PartialOrd<StackString<C1>> for StackString<C2> {
     #[inline]
-    fn partial_cmp(&self, other: &StackString<C1>) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &StackString<C1>) -> Option<core::cmp::Ordering> {
         self.as_str().partial_cmp(other.as_str())
     }
 }
 
 impl<const CAPACITY: usize> PartialOrd<str> for StackString<CAPACITY> {
     #[inline]
-    fn partial_cmp(&self, other: &str) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &str) -> Option<core::cmp::Ordering> {
         self.as_str().partial_cmp(other)
     }
 }
 
 impl<const CAPACITY: usize> PartialOrd<&str> for StackString<CAPACITY> {
     #[inline]
-    fn partial_cmp(&self, other: &&str) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &&str) -> Option<core::cmp::Ordering> {
         self.as_str().partial_cmp(other)
     }
 }
 
 impl<const CAPACITY: usize> PartialOrd<String> for StackString<CAPACITY> {
     #[inline]
-    fn partial_cmp(&self, other: &String) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &String) -> Option<core::cmp::Ordering> {
         self.as_str().partial_cmp(other.as_str())
     }
 }
 
-impl<const CAPACITY: usize> std::hash::Hash for StackString<CAPACITY> {
+impl<const CAPACITY: usize> core::hash::Hash for StackString<CAPACITY> {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.as_str().hash(state);
     }
 }
@@ -366,6 +368,7 @@ impl<const CAPACITY: usize> AsRef<[u8]> for StackString<CAPACITY> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<const CAPACITY: usize> AsRef<std::ffi::OsStr> for StackString<CAPACITY> {
     #[inline]
     fn as_ref(&self) -> &std::ffi::OsStr {
@@ -373,6 +376,7 @@ impl<const CAPACITY: usize> AsRef<std::ffi::OsStr> for StackString<CAPACITY> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<const CAPACITY: usize> AsRef<std::path::Path> for StackString<CAPACITY> {
     #[inline]
     fn as_ref(&self) -> &std::path::Path {
@@ -380,7 +384,7 @@ impl<const CAPACITY: usize> AsRef<std::path::Path> for StackString<CAPACITY> {
     }
 }
 
-impl<const CAPACITY: usize> std::borrow::Borrow<str> for StackString<CAPACITY> {
+impl<const CAPACITY: usize> alloc::borrow::Borrow<str> for StackString<CAPACITY> {
     #[inline]
     fn borrow(&self) -> &str {
         self.as_str()
@@ -414,14 +418,14 @@ impl<const CAPACITY: usize> StrBuffer<CAPACITY> {
     #[cfg(not(feature = "unsafe"))]
     pub(crate) fn as_str(&self, len: usize) -> &str {
         let slice = self.0.get(..len).unwrap();
-        std::str::from_utf8(slice).unwrap()
+        core::str::from_utf8(slice).unwrap()
     }
 
     #[inline]
     #[cfg(not(feature = "unsafe"))]
     pub(crate) fn as_mut_str(&mut self, len: usize) -> &mut str {
         let slice = self.0.get_mut(..len).unwrap();
-        std::str::from_utf8_mut(slice).unwrap()
+        core::str::from_utf8_mut(slice).unwrap()
     }
 }
 
@@ -443,14 +447,14 @@ impl<const CAPACITY: usize> StrBuffer<CAPACITY> {
     #[cfg(feature = "unsafe")]
     pub(crate) unsafe fn as_str_unchecked(&self, len: usize) -> &str {
         let slice = self.0.get_unchecked(..len);
-        std::str::from_utf8_unchecked(slice)
+        core::str::from_utf8_unchecked(slice)
     }
 
     #[inline]
     #[cfg(feature = "unsafe")]
     pub(crate) unsafe fn as_mut_str_unchecked(&mut self, len: usize) -> &mut str {
         let slice = self.0.get_unchecked_mut(..len);
-        std::str::from_utf8_unchecked_mut(slice)
+        core::str::from_utf8_unchecked_mut(slice)
     }
 }
 
diff --git a/src/string.rs b/src/string.rs
index b33ecc2..cf10541 100644
--- a/src/string.rs
+++ b/src/string.rs
@@ -1,10 +1,12 @@
-use std::{borrow::Cow, fmt};
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+use alloc::{borrow::Cow, fmt};
 
 use crate::stack::StackString;
 use crate::KStringCowBase;
 use crate::KStringRef;
 
-pub(crate) type StdString = std::string::String;
+pub(crate) type StdString = alloc::string::String;
 
 /// A UTF-8 encoded, immutable string.
 pub type KString = KStringBase<crate::backend::DefaultStr>;
@@ -107,7 +109,7 @@ impl<B: crate::backend::HeapStr> KStringBase<B> {
     }
 }
 
-impl<B: crate::backend::HeapStr> std::ops::Deref for KStringBase<B> {
+impl<B: crate::backend::HeapStr> core::ops::Deref for KStringBase<B> {
     type Target = str;
 
     #[inline]
@@ -148,21 +150,21 @@ impl<B: crate::backend::HeapStr> PartialEq<String> for KStringBase<B> {
 
 impl<B: crate::backend::HeapStr> Ord for KStringBase<B> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.as_str().cmp(other.as_str())
     }
 }
 
 impl<B: crate::backend::HeapStr> PartialOrd for KStringBase<B> {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<B: crate::backend::HeapStr> std::hash::Hash for KStringBase<B> {
+impl<B: crate::backend::HeapStr> core::hash::Hash for KStringBase<B> {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.as_str().hash(state);
     }
 }
@@ -195,6 +197,7 @@ impl<B: crate::backend::HeapStr> AsRef<[u8]> for KStringBase<B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringBase<B> {
     #[inline]
     fn as_ref(&self) -> &std::ffi::OsStr {
@@ -202,6 +205,7 @@ impl<B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringBase<B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringBase<B> {
     #[inline]
     fn as_ref(&self) -> &std::path::Path {
@@ -209,7 +213,7 @@ impl<B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringBase<B> {
     }
 }
 
-impl<B: crate::backend::HeapStr> std::borrow::Borrow<str> for KStringBase<B> {
+impl<B: crate::backend::HeapStr> alloc::borrow::Borrow<str> for KStringBase<B> {
     #[inline]
     fn borrow(&self) -> &str {
         self.as_str()
@@ -286,8 +290,8 @@ impl<B: crate::backend::HeapStr> From<&'static str> for KStringBase<B> {
     }
 }
 
-impl<B: crate::backend::HeapStr> std::str::FromStr for KStringBase<B> {
-    type Err = std::convert::Infallible;
+impl<B: crate::backend::HeapStr> core::str::FromStr for KStringBase<B> {
+    type Err = core::convert::Infallible;
     #[inline]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(Self::from_ref(s))
@@ -311,12 +315,12 @@ impl<'de, B: crate::backend::HeapStr> serde::Deserialize<'de> for KStringBase<B>
     where
         D: serde::Deserializer<'de>,
     {
-        deserializer.deserialize_string(StringVisitor(std::marker::PhantomData))
+        deserializer.deserialize_string(StringVisitor(core::marker::PhantomData))
     }
 }
 
 #[cfg(feature = "serde")]
-struct StringVisitor<B>(std::marker::PhantomData<B>);
+struct StringVisitor<B>(core::marker::PhantomData<B>);
 
 #[cfg(feature = "serde")]
 impl<B: crate::backend::HeapStr> serde::de::Visitor<'_> for StringVisitor<B> {
@@ -344,7 +348,7 @@ impl<B: crate::backend::HeapStr> serde::de::Visitor<'_> for StringVisitor<B> {
     where
         E: serde::de::Error,
     {
-        match std::str::from_utf8(v) {
+        match core::str::from_utf8(v) {
             Ok(s) => Ok(Self::Value::from_ref(s)),
             Err(_) => Err(serde::de::Error::invalid_value(
                 serde::de::Unexpected::Bytes(v),
@@ -476,20 +480,20 @@ mod inner {
     }
 
     #[allow(unused)]
-    const LEN_SIZE: usize = std::mem::size_of::<crate::stack::Len>();
+    const LEN_SIZE: usize = core::mem::size_of::<crate::stack::Len>();
 
     #[allow(unused)]
-    const TAG_SIZE: usize = std::mem::size_of::<u8>();
+    const TAG_SIZE: usize = core::mem::size_of::<u8>();
 
     #[allow(unused)]
     const MAX_CAPACITY: usize =
-        std::mem::size_of::<crate::string::StdString>() - TAG_SIZE - LEN_SIZE;
+        core::mem::size_of::<crate::string::StdString>() - TAG_SIZE - LEN_SIZE;
 
     // Performance seems to slow down when trying to occupy all of the padding left by `String`'s
     // discriminant.  The question is whether faster len=1-16 "allocations" outweighs going to the heap
     // for len=17-22.
     #[allow(unused)]
-    const ALIGNED_CAPACITY: usize = std::mem::size_of::<crate::backend::DefaultStr>() - LEN_SIZE;
+    const ALIGNED_CAPACITY: usize = core::mem::size_of::<crate::backend::DefaultStr>() - LEN_SIZE;
 
     #[cfg(feature = "max_inline")]
     const CAPACITY: usize = MAX_CAPACITY;
@@ -505,7 +509,7 @@ mod inner {
     pub(super) union KStringInner<B> {
         tag: TagVariant,
         singleton: SingletonVariant,
-        owned: std::mem::ManuallyDrop<OwnedVariant<B>>,
+        owned: core::mem::ManuallyDrop<OwnedVariant<B>>,
         inline: InlineVariant,
     }
 
@@ -540,7 +544,7 @@ mod inner {
             #[allow(clippy::useless_conversion)]
             let payload = B::from_boxed_str(other);
             Self {
-                owned: std::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
+                owned: core::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
             }
         }
 
@@ -573,7 +577,7 @@ mod inner {
                 #[allow(clippy::useless_conversion)]
                 let payload = B::from_str(other);
                 Self {
-                    owned: std::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
+                    owned: core::mem::ManuallyDrop::new(OwnedVariant::new(payload)),
                 }
             }
         }
@@ -659,7 +663,7 @@ mod inner {
                 unsafe {
                     // SAFETY: `tag` ensures access to correct variant
                     Self {
-                        owned: std::mem::ManuallyDrop::new(OwnedVariant::new(
+                        owned: core::mem::ManuallyDrop::new(OwnedVariant::new(
                             self.owned.payload.clone(),
                         )),
                     }
@@ -668,7 +672,7 @@ mod inner {
                 unsafe {
                     // SAFETY: `tag` ensures access to correct variant
                     // SAFETY: non-owned types are copyable
-                    std::mem::transmute_copy(self)
+                    core::mem::transmute_copy(self)
                 }
             }
         }
@@ -680,24 +684,24 @@ mod inner {
             if tag.is_owned() {
                 unsafe {
                     // SAFETY: `tag` ensures we are using the right variant
-                    std::mem::ManuallyDrop::drop(&mut self.owned)
+                    core::mem::ManuallyDrop::drop(&mut self.owned)
                 }
             }
         }
     }
 
     #[allow(unused)]
-    const LEN_SIZE: usize = std::mem::size_of::<crate::stack::Len>();
+    const LEN_SIZE: usize = core::mem::size_of::<crate::stack::Len>();
 
     #[allow(unused)]
-    const TAG_SIZE: usize = std::mem::size_of::<Tag>();
+    const TAG_SIZE: usize = core::mem::size_of::<Tag>();
 
     #[allow(unused)]
-    const PAYLOAD_SIZE: usize = std::mem::size_of::<crate::backend::DefaultStr>();
+    const PAYLOAD_SIZE: usize = core::mem::size_of::<crate::backend::DefaultStr>();
     type Payload = Padding<PAYLOAD_SIZE>;
 
     #[allow(unused)]
-    const TARGET_SIZE: usize = std::mem::size_of::<Target>();
+    const TARGET_SIZE: usize = core::mem::size_of::<Target>();
     type Target = crate::string::StdString;
 
     #[allow(unused)]
@@ -747,9 +751,9 @@ mod inner {
         }
     }
 
-    impl std::fmt::Debug for SingletonVariant {
+    impl core::fmt::Debug for SingletonVariant {
         #[inline]
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             self.payload.fmt(f)
         }
     }
@@ -775,9 +779,9 @@ mod inner {
         }
     }
 
-    impl<B: crate::backend::HeapStr> std::fmt::Debug for OwnedVariant<B> {
+    impl<B: crate::backend::HeapStr> core::fmt::Debug for OwnedVariant<B> {
         #[inline]
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             self.payload.fmt(f)
         }
     }
@@ -802,9 +806,9 @@ mod inner {
         }
     }
 
-    impl std::fmt::Debug for InlineVariant {
+    impl core::fmt::Debug for InlineVariant {
         #[inline]
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             self.payload.fmt(f)
         }
     }
@@ -836,13 +840,13 @@ mod inner {
 
     #[derive(Copy, Clone)]
     #[repr(transparent)]
-    struct Padding<const L: usize>([std::mem::MaybeUninit<u8>; L]);
+    struct Padding<const L: usize>([core::mem::MaybeUninit<u8>; L]);
 
     impl<const L: usize> Padding<L> {
         const fn new() -> Self {
             let padding = unsafe {
                 // SAFETY: Padding, never actually used
-                std::mem::MaybeUninit::uninit().assume_init()
+                core::mem::MaybeUninit::uninit().assume_init()
             };
             Self(padding)
         }
@@ -861,6 +865,6 @@ mod test {
 
     #[test]
     fn test_size() {
-        println!("KString: {}", std::mem::size_of::<KString>());
+        println!("KString: {}", core::mem::size_of::<KString>());
     }
 }
diff --git a/src/string_cow.rs b/src/string_cow.rs
index 93962c5..ee5c108 100644
--- a/src/string_cow.rs
+++ b/src/string_cow.rs
@@ -1,10 +1,14 @@
-use std::{borrow::Cow, fmt};
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+use alloc::{borrow::Cow, fmt};
 
 use crate::KStringBase;
 use crate::KStringRef;
 use crate::KStringRefInner;
 
-type StdString = std::string::String;
+type StdString = alloc::string::String;
 type BoxedStr = Box<str>;
 
 /// A reference to a UTF-8 encoded, immutable string.
@@ -155,7 +159,7 @@ impl<'s, B: crate::backend::HeapStr> KStringCowInner<'s, B> {
     }
 }
 
-impl<B: crate::backend::HeapStr> std::ops::Deref for KStringCowBase<'_, B> {
+impl<B: crate::backend::HeapStr> core::ops::Deref for KStringCowBase<'_, B> {
     type Target = str;
 
     #[inline]
@@ -196,21 +200,21 @@ impl<B: crate::backend::HeapStr> PartialEq<String> for KStringCowBase<'_, B> {
 
 impl<B: crate::backend::HeapStr> Ord for KStringCowBase<'_, B> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.as_str().cmp(other.as_str())
     }
 }
 
 impl<B: crate::backend::HeapStr> PartialOrd for KStringCowBase<'_, B> {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<B: crate::backend::HeapStr> std::hash::Hash for KStringCowBase<'_, B> {
+impl<B: crate::backend::HeapStr> core::hash::Hash for KStringCowBase<'_, B> {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.as_str().hash(state);
     }
 }
@@ -243,6 +247,7 @@ impl<B: crate::backend::HeapStr> AsRef<[u8]> for KStringCowBase<'_, B> {
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringCowBase<'_, B> {
     #[inline]
     fn as_ref(&self) -> &std::ffi::OsStr {
@@ -250,6 +255,7 @@ impl<B: crate::backend::HeapStr> AsRef<std::ffi::OsStr> for KStringCowBase<'_, B
     }
 }
 
+#[cfg(feature = "std")]
 impl<B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringCowBase<'_, B> {
     #[inline]
     fn as_ref(&self) -> &std::path::Path {
@@ -257,7 +263,7 @@ impl<B: crate::backend::HeapStr> AsRef<std::path::Path> for KStringCowBase<'_, B
     }
 }
 
-impl<B: crate::backend::HeapStr> std::borrow::Borrow<str> for KStringCowBase<'_, B> {
+impl<B: crate::backend::HeapStr> core::borrow::Borrow<str> for KStringCowBase<'_, B> {
     #[inline]
     fn borrow(&self) -> &str {
         self.as_str()
@@ -343,8 +349,8 @@ impl<'s, B: crate::backend::HeapStr> From<&'s str> for KStringCowBase<'s, B> {
     }
 }
 
-impl<B: crate::backend::HeapStr> std::str::FromStr for KStringCowBase<'_, B> {
-    type Err = std::convert::Infallible;
+impl<B: crate::backend::HeapStr> core::str::FromStr for KStringCowBase<'_, B> {
+    type Err = core::convert::Infallible;
     #[inline]
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(Self::from_string(s.into()))
@@ -378,6 +384,9 @@ mod test {
 
     #[test]
     fn test_size() {
-        println!("KStringCow: {}", std::mem::size_of::<KStringCow<'static>>());
+        println!(
+            "KStringCow: {}",
+            core::mem::size_of::<KStringCow<'static>>()
+        );
     }
 }
diff --git a/src/string_ref.rs b/src/string_ref.rs
index 31ff1d5..2c69583 100644
--- a/src/string_ref.rs
+++ b/src/string_ref.rs
@@ -1,9 +1,15 @@
-use std::fmt;
+#[cfg(not(feature = "std"))]
+use crate::alloc::borrow::ToOwned;
+#[cfg(not(feature = "std"))]
+use alloc::boxed::Box;
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+use core::fmt;
 
 use crate::KStringBase;
 use crate::KStringCowBase;
 
-type StdString = std::string::String;
+type StdString = alloc::string::String;
 type BoxedStr = Box<str>;
 
 /// A reference to a UTF-8 encoded, immutable string.
@@ -92,7 +98,7 @@ impl KStringRefInner<'_> {
     }
 }
 
-impl std::ops::Deref for KStringRef<'_> {
+impl core::ops::Deref for KStringRef<'_> {
     type Target = str;
 
     #[inline]
@@ -133,21 +139,21 @@ impl PartialEq<String> for KStringRef<'_> {
 
 impl Ord for KStringRef<'_> {
     #[inline]
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         self.as_str().cmp(other.as_str())
     }
 }
 
 impl PartialOrd for KStringRef<'_> {
     #[inline]
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl std::hash::Hash for KStringRef<'_> {
+impl core::hash::Hash for KStringRef<'_> {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.as_str().hash(state);
     }
 }
@@ -180,6 +186,7 @@ impl AsRef<[u8]> for KStringRef<'_> {
     }
 }
 
+#[cfg(feature = "std")]
 impl AsRef<std::ffi::OsStr> for KStringRef<'_> {
     #[inline]
     fn as_ref(&self) -> &std::ffi::OsStr {
@@ -187,6 +194,7 @@ impl AsRef<std::ffi::OsStr> for KStringRef<'_> {
     }
 }
 
+#[cfg(feature = "std")]
 impl AsRef<std::path::Path> for KStringRef<'_> {
     #[inline]
     fn as_ref(&self) -> &std::path::Path {
@@ -194,7 +202,7 @@ impl AsRef<std::path::Path> for KStringRef<'_> {
     }
 }
 
-impl std::borrow::Borrow<str> for KStringRef<'_> {
+impl alloc::borrow::Borrow<str> for KStringRef<'_> {
     #[inline]
     fn borrow(&self) -> &str {
         self.as_str()
@@ -272,6 +280,9 @@ mod test {
 
     #[test]
     fn test_size() {
-        println!("KStringRef: {}", std::mem::size_of::<KStringRef<'static>>());
+        println!(
+            "KStringRef: {}",
+            core::mem::size_of::<KStringRef<'static>>()
+        );
     }
 }