diff --git a/CHANGELOG.md b/CHANGELOG.md
index b63bd39b51..9992d86028 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `String::drain`.
 - Implemented `DoubleEndedIterator` for `OldestOrdered`.
 - Added std `Entry` methods to indexmap `Entry`.
+- Added `StringView`, the `!Sized` version of `String`.
 
 ### Changed
 
diff --git a/src/defmt.rs b/src/defmt.rs
index c50963c007..6d547c09b7 100644
--- a/src/defmt.rs
+++ b/src/defmt.rs
@@ -1,6 +1,6 @@
 //! Defmt implementations for heapless types
 
-use crate::{storage::Storage, vec::VecInner};
+use crate::{storage::Storage, string::StringInner, vec::VecInner};
 use defmt::Formatter;
 
 impl<T, S: Storage> defmt::Format for VecInner<T, S>
@@ -12,7 +12,7 @@ where
     }
 }
 
-impl<const N: usize> defmt::Format for crate::String<N>
+impl<S: Storage> defmt::Format for StringInner<S>
 where
     u8: defmt::Format,
 {
diff --git a/src/ser.rs b/src/ser.rs
index 9839da2ac4..cdd4b6bf4b 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,8 +1,8 @@
 use core::hash::{BuildHasher, Hash};
 
 use crate::{
-    binary_heap::Kind as BinaryHeapKind, storage::Storage, vec::VecInner, BinaryHeap, Deque,
-    HistoryBuffer, IndexMap, IndexSet, LinearMap, String,
+    binary_heap::Kind as BinaryHeapKind, storage::Storage, string::StringInner, vec::VecInner,
+    BinaryHeap, Deque, HistoryBuffer, IndexMap, IndexSet, LinearMap,
 };
 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
 
@@ -129,10 +129,10 @@ where
 
 // String containers
 
-impl<const N: usize> Serialize for String<N> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+impl<S: Storage> Serialize for StringInner<S> {
+    fn serialize<SER>(&self, serializer: SER) -> Result<SER::Ok, SER::Error>
     where
-        S: Serializer,
+        SER: Serializer,
     {
         serializer.serialize_str(&*self)
     }
diff --git a/src/string/drain.rs b/src/string/drain.rs
index c547e5f4b2..11a708c2e7 100644
--- a/src/string/drain.rs
+++ b/src/string/drain.rs
@@ -1,17 +1,17 @@
 use core::{fmt, iter::FusedIterator, str::Chars};
 
-use super::String;
+use super::StringView;
 
 /// A draining iterator for `String`.
 ///
-/// This struct is created by the [`drain`] method on [`String`]. See its
+/// This struct is created by the [`drain`] method on [`crate::String`]. See its
 /// documentation for more.
 ///
-/// [`drain`]: String::drain
-pub struct Drain<'a, const N: usize> {
+/// [`drain`]: crate::String::drain
+pub struct Drain<'a> {
     /// Will be used as &'a mut String in the destructor
-    pub(super) string: *mut String<N>,
-    /// Start of part to remove
+    pub(super) string: *mut StringView,
+    /// Stast of part to remove
     pub(super) start: usize,
     /// End of part to remove
     pub(super) end: usize,
@@ -19,16 +19,16 @@ pub struct Drain<'a, const N: usize> {
     pub(super) iter: Chars<'a>,
 }
 
-impl<const N: usize> fmt::Debug for Drain<'_, N> {
+impl fmt::Debug for Drain<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Drain").field(&self.as_str()).finish()
     }
 }
 
-unsafe impl<const N: usize> Sync for Drain<'_, N> {}
-unsafe impl<const N: usize> Send for Drain<'_, N> {}
+unsafe impl Sync for Drain<'_> {}
+unsafe impl Send for Drain<'_> {}
 
-impl<const N: usize> Drop for Drain<'_, N> {
+impl Drop for Drain<'_> {
     fn drop(&mut self) {
         unsafe {
             // Use `Vec::drain`. “Reaffirm” the bounds checks to avoid
@@ -41,7 +41,7 @@ impl<const N: usize> Drop for Drain<'_, N> {
     }
 }
 
-impl<'a, const N: usize> Drain<'a, N> {
+impl<'a> Drain<'a> {
     /// Returns the remaining (sub)string of this iterator as a slice.
     ///
     /// # Examples
@@ -61,19 +61,19 @@ impl<'a, const N: usize> Drain<'a, N> {
     }
 }
 
-impl<const N: usize> AsRef<str> for Drain<'_, N> {
+impl AsRef<str> for Drain<'_> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-impl<const N: usize> AsRef<[u8]> for Drain<'_, N> {
+impl AsRef<[u8]> for Drain<'_> {
     fn as_ref(&self) -> &[u8] {
         self.as_str().as_bytes()
     }
 }
 
-impl<const N: usize> Iterator for Drain<'_, N> {
+impl Iterator for Drain<'_> {
     type Item = char;
 
     #[inline]
@@ -91,18 +91,18 @@ impl<const N: usize> Iterator for Drain<'_, N> {
     }
 }
 
-impl<const N: usize> DoubleEndedIterator for Drain<'_, N> {
+impl DoubleEndedIterator for Drain<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
         self.iter.next_back()
     }
 }
 
-impl<const N: usize> FusedIterator for Drain<'_, N> {}
+impl FusedIterator for Drain<'_> {}
 
 #[cfg(test)]
 mod tests {
-    use super::String;
+    use crate::String;
 
     #[test]
     fn drain_front() {
diff --git a/src/string/mod.rs b/src/string/mod.rs
index ceeac8455e..cabc02e01f 100644
--- a/src/string/mod.rs
+++ b/src/string/mod.rs
@@ -10,7 +10,11 @@ use core::{
     str::{self, Utf8Error},
 };
 
-use crate::Vec;
+use crate::{
+    storage::{OwnedStorage, Storage, ViewStorage},
+    vec::VecInner,
+    Vec,
+};
 
 mod drain;
 pub use drain::Drain;
@@ -37,9 +41,83 @@ impl fmt::Display for FromUtf16Error {
     }
 }
 
+/// Base struct for [`String`] and [`StringView`], generic over the [`Storage`].
+///
+/// In most cases you should use [`String`] or [`StringView`] directly. Only use this
+/// struct if you want to write code that's generic over both.
+pub struct StringInner<S: Storage> {
+    vec: VecInner<u8, S>,
+}
+
 /// A fixed capacity [`String`](https://doc.rust-lang.org/std/string/struct.String.html).
-pub struct String<const N: usize> {
-    vec: Vec<u8, N>,
+pub type String<const N: usize> = StringInner<OwnedStorage<N>>;
+
+/// A dynamic capacity [`String`](https://doc.rust-lang.org/std/string/struct.String.html).
+pub type StringView = StringInner<ViewStorage>;
+
+impl StringView {
+    /// Removes the specified range from the string in bulk, returning all
+    /// removed characters as an iterator.
+    ///
+    /// The returned iterator keeps a mutable borrow on the string to optimize
+    /// its implementation.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the starting point or end point do not lie on a [`char`]
+    /// boundary, or if they're out of bounds.
+    ///
+    /// # Leaking
+    ///
+    /// If the returned iterator goes out of scope without being dropped (due to
+    /// [`core::mem::forget`], for example), the string may still contain a copy
+    /// of any drained characters, or may have lost characters arbitrarily,
+    /// including characters outside the range.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use heapless::String;
+    ///
+    /// let mut s = String::<32>::try_from("α is alpha, β is beta").unwrap();
+    /// let beta_offset = s.find('β').unwrap_or(s.len());
+    ///
+    /// // Remove the range up until the β from the string
+    /// let t: String<32> = s.drain(..beta_offset).collect();
+    /// assert_eq!(t, "α is alpha, ");
+    /// assert_eq!(s, "β is beta");
+    ///
+    /// // A full range clears the string, like `clear()` does
+    /// s.drain(..);
+    /// assert_eq!(s, "");
+    /// ```
+    pub fn drain<R>(&mut self, range: R) -> Drain<'_>
+    where
+        R: RangeBounds<usize>,
+    {
+        // Memory safety
+        //
+        // The `String` version of `Drain` does not have the memory safety issues
+        // of the `Vec` version. The data is just plain bytes.
+        // Because the range removal happens in `Drop`, if the `Drain` iterator is leaked,
+        // the removal will not happen.
+        let Range { start, end } = crate::slice::range(range, ..self.len());
+        assert!(self.is_char_boundary(start));
+        assert!(self.is_char_boundary(end));
+
+        // Take out two simultaneous borrows. The &mut String won't be accessed
+        // until iteration is over, in Drop.
+        let self_ptr = self as *mut _;
+        // SAFETY: `slice::range` and `is_char_boundary` do the appropriate bounds checks.
+        let chars_iter = unsafe { self.get_unchecked(start..end) }.chars();
+
+        Drain {
+            start,
+            end,
+            iter: chars_iter,
+            string: self_ptr,
+        }
+    }
 }
 
 impl<const N: usize> String<N> {
@@ -185,6 +263,92 @@ impl<const N: usize> String<N> {
         self.vec
     }
 
+    /// Get a reference to the `String`, erasing the `N` const-generic.
+    ///
+    ///
+    /// ```rust
+    /// # use heapless::string::{String, StringView};
+    /// let s: String<10> = String::try_from("hello").unwrap();
+    /// let view: &StringView = s.as_view();
+    /// ```
+    ///
+    /// It is often preferable to do the same through type coerction, since `String<N>` implements `Unsize<StringView>`:
+    ///
+    /// ```rust
+    /// # use heapless::string::{String, StringView};
+    /// let s: String<10> = String::try_from("hello").unwrap();
+    /// let view: &StringView = &s;
+    /// ```
+    #[inline]
+    pub fn as_view(&self) -> &StringView {
+        self
+    }
+
+    /// Get a mutable reference to the `String`, erasing the `N` const-generic.
+    ///
+    ///
+    /// ```rust
+    /// # use heapless::string::{String, StringView};
+    /// let mut s: String<10> = String::try_from("hello").unwrap();
+    /// let view: &mut StringView = s.as_mut_view();
+    /// ```
+    ///
+    /// It is often preferable to do the same through type coerction, since `String<N>` implements `Unsize<StringView>`:
+    ///
+    /// ```rust
+    /// # use heapless::string::{String, StringView};
+    /// let mut s: String<10> = String::try_from("hello").unwrap();
+    /// let view: &mut StringView = &mut s;
+    /// ```
+    #[inline]
+    pub fn as_mut_view(&mut self) -> &mut StringView {
+        self
+    }
+
+    /// Removes the specified range from the string in bulk, returning all
+    /// removed characters as an iterator.
+    ///
+    /// The returned iterator keeps a mutable borrow on the string to optimize
+    /// its implementation.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the starting point or end point do not lie on a [`char`]
+    /// boundary, or if they're out of bounds.
+    ///
+    /// # Leaking
+    ///
+    /// If the returned iterator goes out of scope without being dropped (due to
+    /// [`core::mem::forget`], for example), the string may still contain a copy
+    /// of any drained characters, or may have lost characters arbitrarily,
+    /// including characters outside the range.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use heapless::String;
+    ///
+    /// let mut s = String::<32>::try_from("α is alpha, β is beta").unwrap();
+    /// let beta_offset = s.find('β').unwrap_or(s.len());
+    ///
+    /// // Remove the range up until the β from the string
+    /// let t: String<32> = s.drain(..beta_offset).collect();
+    /// assert_eq!(t, "α is alpha, ");
+    /// assert_eq!(s, "β is beta");
+    ///
+    /// // A full range clears the string, like `clear()` does
+    /// s.drain(..);
+    /// assert_eq!(s, "");
+    /// ```
+    pub fn drain<R>(&mut self, range: R) -> Drain<'_>
+    where
+        R: RangeBounds<usize>,
+    {
+        self.as_mut_view().drain(range)
+    }
+}
+
+impl<S: Storage> StringInner<S> {
     /// Extracts a string slice containing the entire string.
     ///
     /// # Examples
@@ -252,7 +416,7 @@ impl<const N: usize> String<N> {
     /// assert_eq!(s, "olleh");
     /// # Ok::<(), ()>(())
     /// ```
-    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8, N> {
+    pub unsafe fn as_mut_vec(&mut self) -> &mut VecInner<u8, S> {
         &mut self.vec
     }
 
@@ -460,69 +624,6 @@ impl<const N: usize> String<N> {
     pub fn clear(&mut self) {
         self.vec.clear()
     }
-
-    /// Removes the specified range from the string in bulk, returning all
-    /// removed characters as an iterator.
-    ///
-    /// The returned iterator keeps a mutable borrow on the string to optimize
-    /// its implementation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
-    ///
-    /// # Leaking
-    ///
-    /// If the returned iterator goes out of scope without being dropped (due to
-    /// [`core::mem::forget`], for example), the string may still contain a copy
-    /// of any drained characters, or may have lost characters arbitrarily,
-    /// including characters outside the range.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use heapless::String;
-    ///
-    /// let mut s = String::<32>::try_from("α is alpha, β is beta").unwrap();
-    /// let beta_offset = s.find('β').unwrap_or(s.len());
-    ///
-    /// // Remove the range up until the β from the string
-    /// let t: String<32> = s.drain(..beta_offset).collect();
-    /// assert_eq!(t, "α is alpha, ");
-    /// assert_eq!(s, "β is beta");
-    ///
-    /// // A full range clears the string, like `clear()` does
-    /// s.drain(..);
-    /// assert_eq!(s, "");
-    /// ```
-    pub fn drain<R>(&mut self, range: R) -> Drain<'_, N>
-    where
-        R: RangeBounds<usize>,
-    {
-        // Memory safety
-        //
-        // The `String` version of `Drain` does not have the memory safety issues
-        // of the `Vec` version. The data is just plain bytes.
-        // Because the range removal happens in `Drop`, if the `Drain` iterator is leaked,
-        // the removal will not happen.
-        let Range { start, end } = crate::slice::range(range, ..self.len());
-        assert!(self.is_char_boundary(start));
-        assert!(self.is_char_boundary(end));
-
-        // Take out two simultaneous borrows. The &mut String won't be accessed
-        // until iteration is over, in Drop.
-        let self_ptr = self as *mut _;
-        // SAFETY: `slice::range` and `is_char_boundary` do the appropriate bounds checks.
-        let chars_iter = unsafe { self.get_unchecked(start..end) }.chars();
-
-        Drain {
-            start,
-            end,
-            iter: chars_iter,
-            string: self_ptr,
-        }
-    }
 }
 
 impl<const N: usize> Default for String<N> {
@@ -588,26 +689,26 @@ impl<const N: usize> Clone for String<N> {
     }
 }
 
-impl<const N: usize> fmt::Debug for String<N> {
+impl<S: Storage> fmt::Debug for StringInner<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         <str as fmt::Debug>::fmt(self, f)
     }
 }
 
-impl<const N: usize> fmt::Display for String<N> {
+impl<S: Storage> fmt::Display for StringInner<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         <str as fmt::Display>::fmt(self, f)
     }
 }
 
-impl<const N: usize> hash::Hash for String<N> {
+impl<S: Storage> hash::Hash for StringInner<S> {
     #[inline]
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
         <str as hash::Hash>::hash(self, hasher)
     }
 }
 
-impl<const N: usize> fmt::Write for String<N> {
+impl<S: Storage> fmt::Write for StringInner<S> {
     fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
         self.push_str(s).map_err(|_| fmt::Error)
     }
@@ -617,7 +718,7 @@ impl<const N: usize> fmt::Write for String<N> {
     }
 }
 
-impl<const N: usize> ops::Deref for String<N> {
+impl<S: Storage> ops::Deref for StringInner<S> {
     type Target = str;
 
     fn deref(&self) -> &str {
@@ -625,34 +726,34 @@ impl<const N: usize> ops::Deref for String<N> {
     }
 }
 
-impl<const N: usize> ops::DerefMut for String<N> {
+impl<S: Storage> ops::DerefMut for StringInner<S> {
     fn deref_mut(&mut self) -> &mut str {
         self.as_mut_str()
     }
 }
 
-impl<const N: usize> AsRef<str> for String<N> {
+impl<S: Storage> AsRef<str> for StringInner<S> {
     #[inline]
     fn as_ref(&self) -> &str {
         self
     }
 }
 
-impl<const N: usize> AsRef<[u8]> for String<N> {
+impl<S: Storage> AsRef<[u8]> for StringInner<S> {
     #[inline]
     fn as_ref(&self) -> &[u8] {
         self.as_bytes()
     }
 }
 
-impl<const N1: usize, const N2: usize> PartialEq<String<N2>> for String<N1> {
-    fn eq(&self, rhs: &String<N2>) -> bool {
+impl<S1: Storage, S2: Storage> PartialEq<StringInner<S1>> for StringInner<S2> {
+    fn eq(&self, rhs: &StringInner<S1>) -> bool {
         str::eq(&**self, &**rhs)
     }
 }
 
 // String<N> == str
-impl<const N: usize> PartialEq<str> for String<N> {
+impl<S: Storage> PartialEq<str> for StringInner<S> {
     #[inline]
     fn eq(&self, other: &str) -> bool {
         str::eq(self, other)
@@ -660,7 +761,7 @@ impl<const N: usize> PartialEq<str> for String<N> {
 }
 
 // String<N> == &'str
-impl<const N: usize> PartialEq<&str> for String<N> {
+impl<S: Storage> PartialEq<&str> for StringInner<S> {
     #[inline]
     fn eq(&self, other: &&str) -> bool {
         str::eq(self, &other[..])
@@ -668,31 +769,31 @@ impl<const N: usize> PartialEq<&str> for String<N> {
 }
 
 // str == String<N>
-impl<const N: usize> PartialEq<String<N>> for str {
+impl<S: Storage> PartialEq<StringInner<S>> for str {
     #[inline]
-    fn eq(&self, other: &String<N>) -> bool {
+    fn eq(&self, other: &StringInner<S>) -> bool {
         str::eq(self, &other[..])
     }
 }
 
 // &'str == String<N>
-impl<const N: usize> PartialEq<String<N>> for &str {
+impl<S: Storage> PartialEq<StringInner<S>> for &str {
     #[inline]
-    fn eq(&self, other: &String<N>) -> bool {
+    fn eq(&self, other: &StringInner<S>) -> bool {
         str::eq(self, &other[..])
     }
 }
 
-impl<const N: usize> Eq for String<N> {}
+impl<S: Storage> Eq for StringInner<S> {}
 
-impl<const N1: usize, const N2: usize> PartialOrd<String<N2>> for String<N1> {
+impl<S1: Storage, S2: Storage> PartialOrd<StringInner<S1>> for StringInner<S2> {
     #[inline]
-    fn partial_cmp(&self, other: &String<N2>) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &StringInner<S1>) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
 
-impl<const N: usize> Ord for String<N> {
+impl<S: Storage> Ord for StringInner<S> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         Ord::cmp(&**self, &**other)
diff --git a/src/ufmt.rs b/src/ufmt.rs
index fd0b276c40..002ce04c46 100644
--- a/src/ufmt.rs
+++ b/src/ufmt.rs
@@ -1,7 +1,7 @@
-use crate::{storage::Storage, string::String, vec::VecInner};
+use crate::{storage::Storage, string::StringInner, vec::VecInner};
 use ufmt_write::uWrite;
 
-impl<const N: usize> uWrite for String<N> {
+impl<S: Storage> uWrite for StringInner<S> {
     type Error = ();
     fn write_str(&mut self, s: &str) -> Result<(), Self::Error> {
         self.push_str(s)