diff --git a/rust/flexbuffers/src/buffer.rs b/rust/flexbuffers/src/buffer.rs
new file mode 100644
index 0000000..4643cb8
--- /dev/null
+++ b/rust/flexbuffers/src/buffer.rs
@@ -0,0 +1,80 @@
+use std::ops::{Deref, Range};
+
+/// The underlying buffer that is used by a flexbuffer Reader.
+///
+/// This allows for custom buffer implementations as long as they can be viewed as a &[u8].
+pub trait Buffer: Deref<Target = [u8]> + Sized {
+    // The `BufferString` allows for a buffer to return a custom string which will have the
+    // lifetime of the underlying buffer. A simple `std::str::from_utf8` wouldn't work since that
+    // returns a &str, which is then owned by the callee (cannot be returned from a function).
+    //
+    // Example: During deserialization a `BufferString` is returned, allowing the deserializer
+    // to "borrow" the given str - b/c there is a "lifetime" guarantee, so to speak, from the
+    // underlying buffer.
+    /// A BufferString which will live at least as long as the Buffer itself.
+    ///
+    /// Deref's to UTF-8 `str`, and only generated from the `buffer_str` function Result.
+    type BufferString: Deref<Target = str> + Sized + serde::ser::Serialize;
+
+    /// This method returns an instance of type Self. This allows for lifetimes to be tracked
+    /// in cases of deserialization.
+    ///
+    /// It also lets custom buffers manage reference counts.
+    ///
+    /// Returns None if:
+    /// - range start is greater than end
+    /// - range end is out of bounds
+    ///
+    /// This operation should be fast -> O(1), ideally with no heap allocations.
+    fn slice(&self, range: Range<usize>) -> Option<Self>;
+
+    /// Creates a shallow copy of the given buffer, similar to `slice`.
+    ///
+    /// This operation should be fast -> O(1), ideally with no heap allocations.
+    #[inline]
+    fn shallow_copy(&self) -> Self {
+        self.slice(0..self.len()).unwrap()
+    }
+
+    /// Creates an empty instance of a `Buffer`. This is different than `Default` b/c it
+    /// guarantees that the buffer instance will have length zero.
+    ///
+    /// Most impls shold be able to implement this via `Default`.
+    fn empty() -> Self;
+
+    /// Based off of the `empty` function, allows override for optimization purposes.
+    #[inline]
+    fn empty_str() -> Self::BufferString {
+        Self::empty().buffer_str().unwrap()
+    }
+
+    /// Attempts to convert the given buffer to a custom string type.
+    ///
+    /// This should fail if the type does not have valid UTF-8 bytes, and must be zero copy.
+    fn buffer_str(&self) -> Result<Self::BufferString, std::str::Utf8Error>;
+}
+
+impl<'de> Buffer for &'de [u8] {
+    type BufferString = &'de str;
+
+    #[inline]
+    fn slice(&self, range: Range<usize>) -> Option<Self> {
+        self.get(range)
+    }
+
+    #[inline]
+    fn empty() -> Self {
+        &[]
+    }
+
+    /// Based off of the `empty` function, allows override for optimization purposes.
+    #[inline]
+    fn empty_str() -> Self::BufferString {
+        &""
+    }
+
+    #[inline]
+    fn buffer_str(&self) -> Result<Self::BufferString, std::str::Utf8Error> {
+        std::str::from_utf8(self)
+    }
+}
diff --git a/rust/flexbuffers/src/builder/map.rs b/rust/flexbuffers/src/builder/map.rs
index 1635f64..18d7687 100644
--- a/rust/flexbuffers/src/builder/map.rs
+++ b/rust/flexbuffers/src/builder/map.rs
@@ -97,8 +97,7 @@
     // preferred over custom sorting or adding another dependency. By construction, this part
     // of the values stack must be alternating (key, value) pairs. The public API must not be
     // able to trigger the above debug_assets that protect this unsafe usage.
-    let pairs: &mut [[Value; 2]] =
-        unsafe { std::slice::from_raw_parts_mut(raw_pairs, pairs_len) };
+    let pairs: &mut [[Value; 2]] = unsafe { std::slice::from_raw_parts_mut(raw_pairs, pairs_len) };
     #[rustfmt::skip]
     pairs.sort_unstable_by(|[key1, _], [key2, _]| {
         if let Value::Key(a1) = *key1 {
diff --git a/rust/flexbuffers/src/builder/mod.rs b/rust/flexbuffers/src/builder/mod.rs
index e71acd0..97838c2 100644
--- a/rust/flexbuffers/src/builder/mod.rs
+++ b/rust/flexbuffers/src/builder/mod.rs
@@ -32,10 +32,11 @@
         fn $push_name<T, S>(&mut self, xs: S)
         where
             T: Into<$scalar> + Copy,
-            S: AsRef<[T]>
+            S: AsRef<[T]>,
         {
             let mut value = Value::$new_vec(xs.as_ref().len());
-            let mut width = xs.as_ref()
+            let mut width = xs
+                .as_ref()
                 .iter()
                 .map(|x| BitWidth::from((*x).into()))
                 .max()
@@ -56,7 +57,7 @@
             value.set_child_width_or_panic(width);
             self.values.push(value);
         }
-    }
+    };
 }
 macro_rules! push_indirect {
     ($push_name: ident, $scalar: ty, $Direct: ident, $Indirect: ident) => {
@@ -65,15 +66,13 @@
             let child_width = x.width_or_child_width();
             let address = self.buffer.len();
             store_value(&mut self.buffer, x, child_width);
-            self.values.push(
-                Value::Reference {
-                    address,
-                    child_width,
-                    fxb_type: FlexBufferType::$Indirect,
-                }
-            );
+            self.values.push(Value::Reference {
+                address,
+                child_width,
+                fxb_type: FlexBufferType::$Indirect,
+            });
         }
-    }
+    };
 }
 
 bitflags! {
@@ -242,9 +241,7 @@
         let address = self.buffer.len();
         for &b in xs.iter() {
             self.buffer.push(b as u8);
-            for _ in 0..width as u8 {
-                self.buffer.push(0); // Well this seems wasteful.
-            }
+            self.buffer.resize(self.buffer.len() + width as usize, 0);
         }
         self.values.push(Value::Reference {
             fxb_type: FlexBufferType::VectorBool,
diff --git a/rust/flexbuffers/src/builder/push.rs b/rust/flexbuffers/src/builder/push.rs
index d22b47f..5cb584d 100644
--- a/rust/flexbuffers/src/builder/push.rs
+++ b/rust/flexbuffers/src/builder/push.rs
@@ -14,9 +14,9 @@
 
 use crate::builder::Builder;
 use crate::private::Sealed;
-use crate::{Blob, IndirectFloat, IndirectInt, IndirectUInt};
+use crate::{Blob, Buffer, IndirectFloat, IndirectInt, IndirectUInt};
 
-impl<'a> Sealed for Blob<'a> {}
+impl<B: Buffer> Sealed for Blob<B> {}
 impl Sealed for () {}
 
 // TODO: String interning
@@ -44,9 +44,10 @@
         builder.push_null();
     }
 }
-impl<'a> Pushable for Blob<'a> {
+
+impl<B: Buffer> Pushable for Blob<B> {
     fn push_to_builder(self, builder: &mut Builder) {
-        builder.push_blob(self.0);
+        builder.push_blob(&self.0);
     }
 }
 
diff --git a/rust/flexbuffers/src/builder/ser.rs b/rust/flexbuffers/src/builder/ser.rs
index 8e483ba..7ef7757 100644
--- a/rust/flexbuffers/src/builder/ser.rs
+++ b/rust/flexbuffers/src/builder/ser.rs
@@ -36,6 +36,10 @@
     pub fn take_buffer(&mut self) -> Vec<u8> {
         self.builder.take_buffer()
     }
+    pub fn reset(&mut self) {
+        self.builder.reset();
+        self.nesting.clear();
+    }
     fn finish_if_not_nested(&mut self) -> Result<(), Error> {
         if self.nesting.is_empty() {
             assert_eq!(self.builder.values.len(), 1);
diff --git a/rust/flexbuffers/src/builder/value.rs b/rust/flexbuffers/src/builder/value.rs
index f230c34..88ff7b9 100644
--- a/rust/flexbuffers/src/builder/value.rs
+++ b/rust/flexbuffers/src/builder/value.rs
@@ -129,9 +129,10 @@
         !self.is_inline()
     }
     pub fn is_key(&self) -> bool {
-        match self {
-            Value::Key(_) => true,
-            _ => false,
+        if let Value::Key(_) = self {
+            true
+        } else {
+            false
         }
     }
     pub fn is_typed_vector_or_map(&self) -> bool {
diff --git a/rust/flexbuffers/src/flexbuffer_type.rs b/rust/flexbuffers/src/flexbuffer_type.rs
index 5b57de8..eda5195 100644
--- a/rust/flexbuffers/src/flexbuffer_type.rs
+++ b/rust/flexbuffers/src/flexbuffer_type.rs
@@ -134,7 +134,7 @@
     /// Returns true if called on a map, vector, typed vector, or fixed length typed vector.
     pub fn is_vector(self) -> bool {
         let d = self as u8;
-        9 <= d && d < 25 || self == VectorBool
+        (9..25).contains(&d) || self == VectorBool
     }
     /// True iff the binary format stores the length.
     /// This applies to Blob, String, Maps, and Vectors of variable length.
diff --git a/rust/flexbuffers/src/lib.rs b/rust/flexbuffers/src/lib.rs
index 20983b7..2935190 100644
--- a/rust/flexbuffers/src/lib.rs
+++ b/rust/flexbuffers/src/lib.rs
@@ -28,6 +28,10 @@
 //             Serializable structs are Pushable
 //             Serde with maps - field names and type names.
 
+// Until flat/flexbuffers is on Rust v1.42, we cannot use the previously unstable matches! macro.
+#![allow(clippy::unknown_clippy_lints)]
+#![allow(clippy::match_like_matches_macro)]
+
 #[macro_use]
 extern crate bitflags;
 extern crate byteorder;
@@ -37,10 +41,13 @@
 extern crate serde;
 
 mod bitwidth;
+mod buffer;
 mod builder;
 mod flexbuffer_type;
 mod reader;
+
 pub use bitwidth::BitWidth;
+pub use buffer::Buffer;
 pub use builder::Error as SerializationError;
 pub use builder::{
     singleton, Builder, BuilderOptions, FlexbufferSerializer, MapBuilder, Pushable, VectorBuilder,
@@ -60,17 +67,32 @@
     x.serialize(&mut s)?;
     Ok(s.take_buffer())
 }
+
 /// Deserialize a type from a flexbuffer.
 pub fn from_slice<'de, T: Deserialize<'de>>(buf: &'de [u8]) -> Result<T, DeserializationError> {
     let r = Reader::get_root(buf)?;
     T::deserialize(r)
 }
 
+/// Deserialize a type from a flexbuffer.
+pub fn from_buffer<'de, T: Deserialize<'de>, B: Buffer>(
+    buf: &'de B,
+) -> Result<T, DeserializationError> {
+    let r = Reader::get_root(buf as &'de [u8])?;
+    T::deserialize(r)
+}
+
 /// This struct, when pushed will be serialized as a `FlexBufferType::Blob`.
 ///
 /// A `Blob` is a variable width `length` followed by that many bytes of data.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct Blob<'a>(pub &'a [u8]);
+#[derive(Debug, PartialEq, Eq)]
+pub struct Blob<B>(pub B);
+
+impl<B: Buffer> Clone for Blob<B> {
+    fn clone(&self) -> Self {
+        Blob(self.0.shallow_copy())
+    }
+}
 
 /// This struct, when pushed, will be serialized as a `FlexBufferType::IndirectUInt`.
 ///
diff --git a/rust/flexbuffers/src/reader/de.rs b/rust/flexbuffers/src/reader/de.rs
index 8cc3b6e..ed2b815 100644
--- a/rust/flexbuffers/src/reader/de.rs
+++ b/rust/flexbuffers/src/reader/de.rs
@@ -35,6 +35,7 @@
         }
     }
 }
+
 impl serde::de::Error for DeserializationError {
     fn custom<T>(msg: T) -> Self
     where
@@ -43,14 +44,16 @@
         Self::Serde(format!("{}", msg))
     }
 }
+
 impl std::convert::From<super::Error> for DeserializationError {
     fn from(e: super::Error) -> Self {
         Self::Reader(e)
     }
 }
 
-impl<'de> SeqAccess<'de> for ReaderIterator<'de> {
+impl<'de> SeqAccess<'de> for ReaderIterator<&'de [u8]> {
     type Error = DeserializationError;
+
     fn next_element_seed<T>(
         &mut self,
         seed: T,
@@ -64,6 +67,7 @@
             Ok(None)
         }
     }
+
     fn size_hint(&self) -> Option<usize> {
         Some(self.len())
     }
@@ -71,12 +75,13 @@
 
 struct EnumReader<'de> {
     variant: &'de str,
-    value: Option<Reader<'de>>,
+    value: Option<Reader<&'de [u8]>>,
 }
 
 impl<'de> EnumAccess<'de> for EnumReader<'de> {
     type Error = DeserializationError;
-    type Variant = Reader<'de>;
+    type Variant = Reader<&'de [u8]>;
+
     fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
     where
         V: DeserializeSeed<'de>,
@@ -87,9 +92,10 @@
 }
 
 struct MapAccessor<'de> {
-    keys: ReaderIterator<'de>,
-    vals: ReaderIterator<'de>,
+    keys: ReaderIterator<&'de [u8]>,
+    vals: ReaderIterator<&'de [u8]>,
 }
+
 impl<'de> MapAccess<'de> for MapAccessor<'de> {
     type Error = DeserializationError;
 
@@ -103,6 +109,7 @@
             Ok(None)
         }
     }
+
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
     where
         V: DeserializeSeed<'de>,
@@ -112,17 +119,20 @@
     }
 }
 
-impl<'de> VariantAccess<'de> for Reader<'de> {
+impl<'de> VariantAccess<'de> for Reader<&'de [u8]> {
     type Error = DeserializationError;
+
     fn unit_variant(self) -> Result<(), Self::Error> {
         Ok(())
     }
+
     fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
     where
         T: DeserializeSeed<'de>,
     {
         seed.deserialize(self)
     }
+
     // Tuple variants have an internally tagged representation. They are vectors where Index 0 is
     // the discriminant and index N is field N-1.
     fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
@@ -131,6 +141,7 @@
     {
         visitor.visit_seq(self.as_vector().iter())
     }
+
     // Struct variants have an internally tagged representation. They are vectors where Index 0 is
     // the discriminant and index N is field N-1.
     fn struct_variant<V>(
@@ -149,7 +160,7 @@
     }
 }
 
-impl<'de> Deserializer<'de> for crate::Reader<'de> {
+impl<'de> Deserializer<'de> for Reader<&'de [u8]> {
     type Error = DeserializationError;
     fn is_human_readable(&self) -> bool {
         cfg!(deserialize_human_readable)
@@ -188,22 +199,26 @@
             (ty, bw) => unreachable!("TODO deserialize_any {:?} {:?}.", ty, bw),
         }
     }
+
     serde::forward_to_deserialize_any! {
         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 str unit unit_struct bytes
         ignored_any map identifier struct tuple tuple_struct seq string
     }
+
     fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
         visitor.visit_char(self.as_u8() as char)
     }
+
     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
         visitor.visit_byte_buf(self.get_blob()?.0.to_vec())
     }
+
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -214,6 +229,7 @@
             visitor.visit_some(self)
         }
     }
+
     fn deserialize_newtype_struct<V>(
         self,
         _name: &'static str,
@@ -224,6 +240,7 @@
     {
         visitor.visit_newtype_struct(self)
     }
+
     fn deserialize_enum<V>(
         self,
         _name: &'static str,
diff --git a/rust/flexbuffers/src/reader/iter.rs b/rust/flexbuffers/src/reader/iter.rs
index 8e06171..267a01f 100644
--- a/rust/flexbuffers/src/reader/iter.rs
+++ b/rust/flexbuffers/src/reader/iter.rs
@@ -12,19 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::{Reader, VectorReader};
+use crate::{Buffer, Reader, VectorReader};
 use std::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
 
 /// Iterates over a flexbuffer vector, typed vector, or map. Yields [Readers](struct.Reader.html).
 ///
 /// If any error occurs, the Reader is defaulted to a Null flexbuffer Reader.
-pub struct ReaderIterator<'de> {
-    pub(super) reader: VectorReader<'de>,
+pub struct ReaderIterator<B> {
+    pub(super) reader: VectorReader<B>,
     pub(super) front: usize,
     end: usize,
 }
-impl<'de> ReaderIterator<'de> {
-    pub(super) fn new(reader: VectorReader<'de>) -> Self {
+
+impl<B: Buffer> ReaderIterator<B> {
+    pub(super) fn new(reader: VectorReader<B>) -> Self {
         let end = reader.len();
         ReaderIterator {
             reader,
@@ -33,8 +34,9 @@
         }
     }
 }
-impl<'de> Iterator for ReaderIterator<'de> {
-    type Item = Reader<'de>;
+
+impl<B: Buffer> Iterator for ReaderIterator<B> {
+    type Item = Reader<B>;
     fn next(&mut self) -> Option<Self::Item> {
         if self.front < self.end {
             let r = self.reader.idx(self.front);
@@ -49,7 +51,8 @@
         (remaining, Some(remaining))
     }
 }
-impl<'de> DoubleEndedIterator for ReaderIterator<'de> {
+
+impl<B: Buffer> DoubleEndedIterator for ReaderIterator<B> {
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.front < self.end {
             self.end -= 1;
@@ -59,5 +62,6 @@
         }
     }
 }
-impl<'de> ExactSizeIterator for ReaderIterator<'de> {}
-impl<'de> FusedIterator for ReaderIterator<'de> {}
+
+impl<B: Buffer> ExactSizeIterator for ReaderIterator<B> {}
+impl<B: Buffer> FusedIterator for ReaderIterator<B> {}
diff --git a/rust/flexbuffers/src/reader/map.rs b/rust/flexbuffers/src/reader/map.rs
index cdf59e0..7d6ada8 100644
--- a/rust/flexbuffers/src/reader/map.rs
+++ b/rust/flexbuffers/src/reader/map.rs
@@ -14,6 +14,7 @@
 
 use super::{deref_offset, unpack_type, Error, Reader, ReaderIterator, VectorReader};
 use crate::BitWidth;
+use crate::Buffer;
 use std::cmp::Ordering;
 use std::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
 
@@ -22,9 +23,8 @@
 /// MapReaders may be indexed with strings or usizes. `index` returns a result type,
 /// which may indicate failure due to a missing key or bad data, `idx` returns an Null Reader in
 /// cases of error.
-#[derive(Default, Clone)]
-pub struct MapReader<'de> {
-    pub(super) buffer: &'de [u8],
+pub struct MapReader<B> {
+    pub(super) buffer: B,
     pub(super) values_address: usize,
     pub(super) keys_address: usize,
     pub(super) values_width: BitWidth,
@@ -32,8 +32,30 @@
     pub(super) length: usize,
 }
 
+impl<B: Buffer> Clone for MapReader<B> {
+    fn clone(&self) -> Self {
+        MapReader {
+            buffer: self.buffer.shallow_copy(),
+            ..*self
+        }
+    }
+}
+
+impl<B: Buffer> Default for MapReader<B> {
+    fn default() -> Self {
+        MapReader {
+            buffer: B::empty(),
+            values_address: usize::default(),
+            keys_address: usize::default(),
+            values_width: BitWidth::default(),
+            keys_width: BitWidth::default(),
+            length: usize::default(),
+        }
+    }
+}
+
 // manual implementation of Debug because buffer slice can't be automatically displayed
-impl<'de> std::fmt::Debug for MapReader<'de> {
+impl<B: Buffer> std::fmt::Debug for MapReader<B> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // skips buffer field
         f.debug_struct("MapReader")
@@ -46,15 +68,17 @@
     }
 }
 
-impl<'de> MapReader<'de> {
+impl<B: Buffer> MapReader<B> {
     /// Returns the number of key/value pairs are in the map.
     pub fn len(&self) -> usize {
         self.length
     }
+
     /// Returns true if the map has zero key/value pairs.
     pub fn is_empty(&self) -> bool {
         self.length == 0
     }
+
     // Using &CStr will eagerly compute the length of the key. &str needs length info AND utf8
     // validation. This version is faster than both.
     fn lazy_strcmp(&self, key_addr: usize, key: &str) -> Ordering {
@@ -62,6 +86,7 @@
         let k = self.buffer[key_addr..].iter().take_while(|&&b| b != b'\0');
         k.cmp(key.as_bytes().iter())
     }
+
     /// Returns the index of a given key in the map.
     pub fn index_key(&self, key: &str) -> Option<usize> {
         let (mut low, mut high) = (0, self.length);
@@ -69,7 +94,7 @@
             let i = (low + high) / 2;
             let key_offset_address = self.keys_address + i * self.keys_width.n_bytes();
             let key_address =
-                deref_offset(self.buffer, key_offset_address, self.keys_width).ok()?;
+                deref_offset(&self.buffer, key_offset_address, self.keys_width).ok()?;
             match self.lazy_strcmp(key_address, key) {
                 Ordering::Equal => return Some(i),
                 Ordering::Less => low = if i == low { i + 1 } else { i },
@@ -78,15 +103,18 @@
         }
         None
     }
+
     /// Index into a map with a key or usize.
-    pub fn index<I: MapReaderIndexer>(&self, i: I) -> Result<Reader<'de>, Error> {
+    pub fn index<I: MapReaderIndexer>(&self, i: I) -> Result<Reader<B>, Error> {
         i.index_map_reader(self)
     }
+
     /// Index into a map with a key or usize. If any errors occur a Null reader is returned.
-    pub fn idx<I: MapReaderIndexer>(&self, i: I) -> Reader<'de> {
+    pub fn idx<I: MapReaderIndexer>(&self, i: I) -> Reader<B> {
         i.index_map_reader(self).unwrap_or_default()
     }
-    fn usize_index(&self, i: usize) -> Result<Reader<'de>, Error> {
+
+    fn usize_index(&self, i: usize) -> Result<Reader<B>, Error> {
         if i >= self.length {
             return Err(Error::IndexOutOfBounds);
         }
@@ -98,22 +126,24 @@
             .ok_or(Error::FlexbufferOutOfBounds)
             .and_then(|&b| unpack_type(b))?;
         Reader::new(
-            &self.buffer,
+            self.buffer.shallow_copy(),
             data_address,
             fxb_type,
             width,
             self.values_width,
         )
     }
-    fn key_index(&self, k: &str) -> Result<Reader<'de>, Error> {
+
+    fn key_index(&self, k: &str) -> Result<Reader<B>, Error> {
         let i = self.index_key(k).ok_or(Error::KeyNotFound)?;
         self.usize_index(i)
     }
+
     /// Iterate over the values of the map.
-    pub fn iter_values(&self) -> ReaderIterator<'de> {
+    pub fn iter_values(&self) -> ReaderIterator<B> {
         ReaderIterator::new(VectorReader {
             reader: Reader {
-                buffer: self.buffer,
+                buffer: self.buffer.shallow_copy(),
                 fxb_type: crate::FlexBufferType::Map,
                 width: self.values_width,
                 address: self.values_address,
@@ -121,17 +151,19 @@
             length: self.length,
         })
     }
+
     /// Iterate over the keys of the map.
     pub fn iter_keys(
         &self,
-    ) -> impl Iterator<Item = &'de str> + DoubleEndedIterator + ExactSizeIterator + FusedIterator
+    ) -> impl Iterator<Item = B::BufferString> + DoubleEndedIterator + ExactSizeIterator + FusedIterator
     {
         self.keys_vector().iter().map(|k| k.as_str())
     }
-    pub fn keys_vector(&self) -> VectorReader<'de> {
+
+    pub fn keys_vector(&self) -> VectorReader<B> {
         VectorReader {
             reader: Reader {
-                buffer: self.buffer,
+                buffer: self.buffer.shallow_copy(),
                 fxb_type: crate::FlexBufferType::VectorKey,
                 width: self.keys_width,
                 address: self.keys_address,
@@ -140,18 +172,21 @@
         }
     }
 }
+
 pub trait MapReaderIndexer {
-    fn index_map_reader<'de>(self, r: &MapReader<'de>) -> Result<Reader<'de>, Error>;
+    fn index_map_reader<B: Buffer>(self, r: &MapReader<B>) -> Result<Reader<B>, Error>;
 }
+
 impl MapReaderIndexer for usize {
     #[inline]
-    fn index_map_reader<'de>(self, r: &MapReader<'de>) -> Result<Reader<'de>, Error> {
+    fn index_map_reader<B: Buffer>(self, r: &MapReader<B>) -> Result<Reader<B>, Error> {
         r.usize_index(self)
     }
 }
+
 impl MapReaderIndexer for &str {
     #[inline]
-    fn index_map_reader<'de>(self, r: &MapReader<'de>) -> Result<Reader<'de>, Error> {
+    fn index_map_reader<B: Buffer>(self, r: &MapReader<B>) -> Result<Reader<B>, Error> {
         r.key_index(self)
     }
 }
diff --git a/rust/flexbuffers/src/reader/mod.rs b/rust/flexbuffers/src/reader/mod.rs
index 4a3f472..c6f51d0 100644
--- a/rust/flexbuffers/src/reader/mod.rs
+++ b/rust/flexbuffers/src/reader/mod.rs
@@ -14,7 +14,7 @@
 
 use crate::bitwidth::BitWidth;
 use crate::flexbuffer_type::FlexBufferType;
-use crate::Blob;
+use crate::{Blob, Buffer};
 use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use std::ops::Rem;
@@ -22,6 +22,7 @@
 mod de;
 mod iter;
 mod map;
+mod serialize;
 mod vector;
 pub use de::DeserializationError;
 pub use iter::ReaderIterator;
@@ -143,16 +144,37 @@
 /// - The `as_T` methods will try their best to return to a value of type `T`
 /// (by casting or even parsing a string if necessary) but ultimately returns `T::default` if it
 /// fails. This behavior is analogous to that of flexbuffers C++.
-#[derive(Default, Clone)]
-pub struct Reader<'de> {
+pub struct Reader<B> {
     fxb_type: FlexBufferType,
     width: BitWidth,
     address: usize,
-    buffer: &'de [u8],
+    buffer: B,
+}
+
+impl<B: Buffer> Clone for Reader<B> {
+    fn clone(&self) -> Self {
+        Reader {
+            fxb_type: self.fxb_type,
+            width: self.width,
+            address: self.address,
+            buffer: self.buffer.shallow_copy(),
+        }
+    }
+}
+
+impl<B: Buffer> Default for Reader<B> {
+    fn default() -> Self {
+        Reader {
+            fxb_type: FlexBufferType::default(),
+            width: BitWidth::default(),
+            address: usize::default(),
+            buffer: B::empty(),
+        }
+    }
 }
 
 // manual implementation of Debug because buffer slice can't be automatically displayed
-impl<'de> std::fmt::Debug for Reader<'de> {
+impl<B> std::fmt::Debug for Reader<B> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // skips buffer field
         f.debug_struct("Reader")
@@ -163,13 +185,12 @@
     }
 }
 
-
 macro_rules! try_cast_fn {
     ($name: ident, $full_width: ident, $Ty: ident) => {
         pub fn $name(&self) -> $Ty {
             self.$full_width().try_into().unwrap_or_default()
         }
-    }
+    };
 }
 
 fn safe_sub(a: usize, b: usize) -> Result<usize, Error> {
@@ -181,16 +202,16 @@
     safe_sub(address, off)
 }
 
-impl<'de> Reader<'de> {
+impl<B: Buffer> Reader<B> {
     fn new(
-        buffer: &'de [u8],
+        buffer: B,
         mut address: usize,
         mut fxb_type: FlexBufferType,
         width: BitWidth,
         parent_width: BitWidth,
     ) -> Result<Self, Error> {
         if fxb_type.is_reference() {
-            address = deref_offset(buffer, address, parent_width)?;
+            address = deref_offset(&buffer, address, parent_width)?;
             // Indirects were dereferenced.
             if let Some(t) = fxb_type.to_direct() {
                 fxb_type = t;
@@ -203,9 +224,10 @@
             buffer,
         })
     }
+
     /// Parses the flexbuffer from the given buffer. Assumes the flexbuffer root is the last byte
     /// of the buffer.
-    pub fn get_root(buffer: &'de [u8]) -> Result<Self, Error> {
+    pub fn get_root(buffer: B) -> Result<Self, Error> {
         let end = buffer.len();
         if end < 3 {
             return Err(Error::FlexbufferOutOfBounds);
@@ -218,21 +240,34 @@
         let address = safe_sub(end - 2, root_width.n_bytes())?;
         Self::new(buffer, address, fxb_type, width, root_width)
     }
+
+    /// Convenience function to get the underlying buffer. By using `shallow_copy`, this preserves
+    /// the lifetime that the underlying buffer has.
+    pub fn buffer(&self) -> B {
+        self.buffer.shallow_copy()
+    }
+
     /// Returns the FlexBufferType of this Reader.
     pub fn flexbuffer_type(&self) -> FlexBufferType {
         self.fxb_type
     }
+
     /// Returns the bitwidth of this Reader.
     pub fn bitwidth(&self) -> BitWidth {
         self.width
     }
+
     /// Returns the length of the Flexbuffer. If the type has no length, or if an error occurs,
     /// 0 is returned.
     pub fn length(&self) -> usize {
         if let Some(len) = self.fxb_type.fixed_length_vector_length() {
             len
         } else if self.fxb_type.has_length_slot() && self.address >= self.width.n_bytes() {
-            read_usize(self.buffer, self.address - self.width.n_bytes(), self.width)
+            read_usize(
+                &self.buffer,
+                self.address - self.width.n_bytes(),
+                self.width,
+            )
         } else {
             0
         }
@@ -240,11 +275,13 @@
     /// Returns true if the flexbuffer is aligned to 8 bytes. This guarantees, for valid
     /// flexbuffers, that the data is correctly aligned in memory and slices can be read directly
     /// e.g. with `get_f64s` or `get_i16s`.
+    #[inline]
     pub fn is_aligned(&self) -> bool {
         (self.buffer.as_ptr() as usize).rem(8) == 0
     }
-    as_default!(as_vector, get_vector, VectorReader<'de>);
-    as_default!(as_map, get_map, MapReader<'de>);
+
+    as_default!(as_vector, get_vector, VectorReader<B>);
+    as_default!(as_map, get_map, MapReader<B>);
 
     fn expect_type(&self, ty: FlexBufferType) -> Result<(), Error> {
         if self.fxb_type == ty {
@@ -266,11 +303,16 @@
             })
         }
     }
-    /// Directly reads a slice of type `T`where `T` is one of `u8,u16,u32,u64,i8,i16,i32,i64,f32,f64`.
+
+    /// Directly reads a slice of type `T` where `T` is one of `u8,u16,u32,u64,i8,i16,i32,i64,f32,f64`.
     /// Returns Err if the type, bitwidth, or memory alignment does not match. Since the bitwidth is
     /// dynamic, its better to use a VectorReader unless you know your data and performance is critical.
     #[cfg(target_endian = "little")]
-    pub fn get_slice<T: ReadLE>(&self) -> Result<&'de [T], Error> {
+    #[deprecated(
+        since = "0.3.0",
+        note = "This function is unsafe - if this functionality is needed use `Reader::buffer::align_to`"
+    )]
+    pub fn get_slice<T: ReadLE>(&self) -> Result<&[T], Error> {
         if self.flexbuffer_type().typed_vector_type() != T::VECTOR_TYPE.typed_vector_type() {
             self.expect_type(T::VECTOR_TYPE)?;
         }
@@ -278,10 +320,11 @@
             self.expect_bw(T::WIDTH)?;
         }
         let end = self.address + self.length() * std::mem::size_of::<T>();
-        let slice = &self
+        let slice: &[u8] = self
             .buffer
             .get(self.address..end)
             .ok_or(Error::FlexbufferOutOfBounds)?;
+
         // `align_to` is required because the point of this function is to directly hand back a
         // slice of scalars. This can fail because Rust's default allocator is not 16byte aligned
         // (though in practice this only happens for small buffers).
@@ -293,6 +336,8 @@
         }
     }
 
+    /// Returns the value of the reader if it is a boolean.
+    /// Otherwise Returns error.
     pub fn get_bool(&self) -> Result<bool, Error> {
         self.expect_type(FlexBufferType::Bool)?;
         Ok(
@@ -301,30 +346,53 @@
                 .any(|&b| b != 0),
         )
     }
-    pub fn get_key(&self) -> Result<&'de str, Error> {
+
+    /// Gets the length of the key if this type is a key.
+    ///
+    /// Otherwise, returns an error.
+    #[inline]
+    fn get_key_len(&self) -> Result<usize, Error> {
         self.expect_type(FlexBufferType::Key)?;
         let (length, _) = self.buffer[self.address..]
             .iter()
             .enumerate()
             .find(|(_, &b)| b == b'\0')
             .unwrap_or((0, &0));
-        let bytes = &self.buffer[self.address..self.address + length];
-        Ok(std::str::from_utf8(bytes)?)
+        Ok(length)
     }
-    pub fn get_blob(&self) -> Result<Blob<'de>, Error> {
+
+    /// Retrieves the string value up until the first `\0` character.
+    pub fn get_key(&self) -> Result<B::BufferString, Error> {
+        let bytes = self
+            .buffer
+            .slice(self.address..self.address + self.get_key_len()?)
+            .ok_or(Error::IndexOutOfBounds)?;
+        Ok(bytes.buffer_str()?)
+    }
+
+    pub fn get_blob(&self) -> Result<Blob<B>, Error> {
         self.expect_type(FlexBufferType::Blob)?;
         Ok(Blob(
-            &self.buffer[self.address..self.address + self.length()],
+            self.buffer
+                .slice(self.address..self.address + self.length())
+                .ok_or(Error::IndexOutOfBounds)?,
         ))
     }
-    pub fn as_blob(&self) -> Blob<'de> {
-        self.get_blob().unwrap_or(Blob(&[]))
+
+    pub fn as_blob(&self) -> Blob<B> {
+        self.get_blob().unwrap_or(Blob(B::empty()))
     }
-    pub fn get_str(&self) -> Result<&'de str, Error> {
+
+    /// Retrieves str pointer, errors if invalid UTF-8, or the provided index
+    /// is out of bounds.
+    pub fn get_str(&self) -> Result<B::BufferString, Error> {
         self.expect_type(FlexBufferType::String)?;
-        let bytes = &self.buffer[self.address..self.address + self.length()];
-        Ok(std::str::from_utf8(bytes)?)
+        let bytes = self
+            .buffer
+            .slice(self.address..self.address + self.length());
+        Ok(bytes.ok_or(Error::ReadUsizeOverflowed)?.buffer_str()?)
     }
+
     fn get_map_info(&self) -> Result<(usize, BitWidth), Error> {
         self.expect_type(FlexBufferType::Map)?;
         if 3 * self.width.n_bytes() >= self.address {
@@ -333,17 +401,18 @@
         let keys_offset_address = self.address - 3 * self.width.n_bytes();
         let keys_width = {
             let kw_addr = self.address - 2 * self.width.n_bytes();
-            let kw = read_usize(self.buffer, kw_addr, self.width);
+            let kw = read_usize(&self.buffer, kw_addr, self.width);
             BitWidth::from_nbytes(kw).ok_or(Error::InvalidMapKeysVectorWidth)
         }?;
         Ok((keys_offset_address, keys_width))
     }
-    pub fn get_map(&self) -> Result<MapReader<'de>, Error> {
+
+    pub fn get_map(&self) -> Result<MapReader<B>, Error> {
         let (keys_offset_address, keys_width) = self.get_map_info()?;
-        let keys_address = deref_offset(self.buffer, keys_offset_address, self.width)?;
+        let keys_address = deref_offset(&self.buffer, keys_offset_address, self.width)?;
         // TODO(cneo): Check that vectors length equals keys length.
         Ok(MapReader {
-            buffer: self.buffer,
+            buffer: self.buffer.shallow_copy(),
             values_address: self.address,
             values_width: self.width,
             keys_address,
@@ -351,6 +420,7 @@
             length: self.length(),
         })
     }
+
     /// Tries to read a FlexBufferType::UInt. Returns Err if the type is not a UInt or if the
     /// address is out of bounds.
     pub fn get_u64(&self) -> Result<u64, Error> {
@@ -443,7 +513,7 @@
             FlexBufferType::Float => self.get_f64().unwrap_or_default() as u64,
             FlexBufferType::String => {
                 if let Ok(s) = self.get_str() {
-                    if let Ok(f) = u64::from_str(s) {
+                    if let Ok(f) = u64::from_str(&s) {
                         return f;
                     }
                 }
@@ -470,7 +540,7 @@
             FlexBufferType::Float => self.get_f64().unwrap_or_default() as i64,
             FlexBufferType::String => {
                 if let Ok(s) = self.get_str() {
-                    if let Ok(f) = i64::from_str(s) {
+                    if let Ok(f) = i64::from_str(&s) {
                         return f;
                     }
                 }
@@ -493,7 +563,7 @@
             FlexBufferType::Float => self.get_f64().unwrap_or_default(),
             FlexBufferType::String => {
                 if let Ok(s) = self.get_str() {
-                    if let Ok(f) = f64::from_str(s) {
+                    if let Ok(f) = f64::from_str(&s) {
                         return f;
                     }
                 }
@@ -508,14 +578,15 @@
     }
 
     /// Returns empty string if you're not trying to read a string.
-    pub fn as_str(&self) -> &'de str {
+    pub fn as_str(&self) -> B::BufferString {
         match self.fxb_type {
-            FlexBufferType::String => self.get_str().unwrap_or_default(),
-            FlexBufferType::Key => self.get_key().unwrap_or_default(),
-            _ => "",
+            FlexBufferType::String => self.get_str().unwrap_or(B::empty_str()),
+            FlexBufferType::Key => self.get_key().unwrap_or(B::empty_str()),
+            _ => B::empty_str(),
         }
     }
-    pub fn get_vector(&self) -> Result<VectorReader<'de>, Error> {
+
+    pub fn get_vector(&self) -> Result<VectorReader<B>, Error> {
         if !self.fxb_type.is_vector() {
             self.expect_type(FlexBufferType::Vector)?;
         };
@@ -526,7 +597,7 @@
     }
 }
 
-impl<'de> fmt::Display for Reader<'de> {
+impl<B: Buffer> fmt::Display for Reader<B> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use FlexBufferType::*;
         match self.flexbuffer_type() {
@@ -534,7 +605,7 @@
             UInt => write!(f, "{}", self.as_u64()),
             Int => write!(f, "{}", self.as_i64()),
             Float => write!(f, "{}", self.as_f64()),
-            Key | String => write!(f, "{:?}", self.as_str()),
+            Key | String => write!(f, "{:?}", &self.as_str() as &str),
             Bool => write!(f, "{}", self.as_bool()),
             Blob => write!(f, "blob"),
             Map => {
@@ -542,9 +613,9 @@
                 let m = self.as_map();
                 let mut pairs = m.iter_keys().zip(m.iter_values());
                 if let Some((k, v)) = pairs.next() {
-                    write!(f, "{:?}: {}", k, v)?;
+                    write!(f, "{:?}: {}", &k as &str, v)?;
                     for (k, v) in pairs {
-                        write!(f, ", {:?}: {}", k, v)?;
+                        write!(f, ", {:?}: {}", &k as &str, v)?;
                     }
                 }
                 write!(f, "}}")
@@ -570,6 +641,7 @@
     let bits = <u32>::from_le_bytes(bytes);
     <f32>::from_bits(bits)
 }
+
 fn f64_from_le_bytes(bytes: [u8; 8]) -> f64 {
     let bits = <u64>::from_le_bytes(bytes);
     <f64>::from_bits(bits)
diff --git a/rust/flexbuffers/src/reader/serialize.rs b/rust/flexbuffers/src/reader/serialize.rs
new file mode 100644
index 0000000..b129da1
--- /dev/null
+++ b/rust/flexbuffers/src/reader/serialize.rs
@@ -0,0 +1,76 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::reader::Reader;
+use crate::Buffer;
+use crate::{BitWidth::*, FlexBufferType::*};
+use serde::ser;
+use serde::ser::{SerializeMap, SerializeSeq};
+
+impl<B: Buffer> ser::Serialize for &Reader<B> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        #[allow(deprecated)]
+        match (self.flexbuffer_type(), self.bitwidth()) {
+            (Null, _) => serializer.serialize_unit(),
+            (Int, W8) | (IndirectInt, W8) => serializer.serialize_i8(self.as_i8()),
+            (Int, W16) | (IndirectInt, W16) => serializer.serialize_i16(self.as_i16()),
+            (Int, W32) | (IndirectInt, W32) => serializer.serialize_i32(self.as_i32()),
+            (Int, W64) | (IndirectInt, W64) => serializer.serialize_i64(self.as_i64()),
+            (UInt, W8) | (IndirectUInt, W8) => serializer.serialize_u8(self.as_u8()),
+            (UInt, W16) | (IndirectUInt, W16) => serializer.serialize_u16(self.as_u16()),
+            (UInt, W32) | (IndirectUInt, W32) => serializer.serialize_u32(self.as_u32()),
+            (UInt, W64) | (IndirectUInt, W64) => serializer.serialize_u64(self.as_u64()),
+            (Float, W32) | (IndirectFloat, W32) => serializer.serialize_f32(self.as_f32()),
+            (Float, _) | (IndirectFloat, _) => serializer.serialize_f64(self.as_f64()),
+            (Bool, _) => serializer.serialize_bool(self.as_bool()),
+            (Key, _) | (String, _) => serializer.serialize_str(&self.as_str()),
+            (Map, _) => {
+                let m = self.as_map();
+                let mut map_serializer = serializer.serialize_map(Some(m.len()))?;
+                for (k, v) in m.iter_keys().zip(m.iter_values()) {
+                    map_serializer.serialize_key(&&k)?;
+                    map_serializer.serialize_value(&&v)?;
+                }
+                map_serializer.end()
+            }
+            (Vector, _)
+            | (VectorInt, _)
+            | (VectorUInt, _)
+            | (VectorFloat, _)
+            | (VectorKey, _)
+            | (VectorString, _)
+            | (VectorBool, _)
+            | (VectorInt2, _)
+            | (VectorUInt2, _)
+            | (VectorFloat2, _)
+            | (VectorInt3, _)
+            | (VectorUInt3, _)
+            | (VectorFloat3, _)
+            | (VectorInt4, _)
+            | (VectorUInt4, _)
+            | (VectorFloat4, _) => {
+                let v = self.as_vector();
+                let mut seq_serializer = serializer.serialize_seq(Some(v.len()))?;
+                for x in v.iter() {
+                    seq_serializer.serialize_element(&&x)?;
+                }
+                seq_serializer.end()
+            }
+            (Blob, _) => serializer.serialize_bytes(&self.as_blob().0),
+        }
+    }
+}
diff --git a/rust/flexbuffers/src/reader/vector.rs b/rust/flexbuffers/src/reader/vector.rs
index 8ba8fe5..6b97e10 100644
--- a/rust/flexbuffers/src/reader/vector.rs
+++ b/rust/flexbuffers/src/reader/vector.rs
@@ -13,22 +13,39 @@
 // limitations under the License.
 
 use super::{unpack_type, Error, Reader, ReaderIterator};
-use crate::{BitWidth, FlexBufferType};
+use crate::{BitWidth, Buffer, FlexBufferType};
 
-#[derive(Default, Clone)]
 /// Allows indexing on any flexbuffer vector type, (heterogenous vector, typed vector, or fixed
 /// length typed vector).
 ///
 /// VectorReaders may be indexed with usize, `index` returns a result type
 /// which may indicate failure due to indexing out of bounds or bad data. `idx` returns a
 /// Null Reader in the event of any failure.
-pub struct VectorReader<'de> {
-    pub(super) reader: Reader<'de>,
+pub struct VectorReader<B> {
+    pub(super) reader: Reader<B>,
     // Cache the length because read_usize can be slow.
     pub(super) length: usize,
 }
 
-impl<'de> VectorReader<'de> {
+impl<B: Buffer> Clone for VectorReader<B> {
+    fn clone(&self) -> Self {
+        VectorReader {
+            reader: self.reader.clone(),
+            ..*self
+        }
+    }
+}
+
+impl<B: Buffer> Default for VectorReader<B> {
+    fn default() -> Self {
+        VectorReader {
+            reader: Reader::default(),
+            length: usize::default(),
+        }
+    }
+}
+
+impl<B: Buffer> VectorReader<B> {
     /// Returns the number of elements in the vector.
     pub fn len(&self) -> usize {
         self.length
@@ -50,25 +67,26 @@
         }
     }
     /// Index into a flexbuffer vector. Any errors are defaulted to Null Readers.
-    pub fn idx(&self, i: usize) -> Reader<'de> {
+    pub fn idx(&self, i: usize) -> Reader<B> {
         self.index(i).unwrap_or_default()
     }
     /// Index into a flexbuffer.
-    pub fn index(&self, i: usize) -> Result<Reader<'de>, Error> {
+    pub fn index(&self, i: usize) -> Result<Reader<B>, Error> {
         if i >= self.length {
             return Err(Error::IndexOutOfBounds);
         }
         let (fxb_type, bw) = self.get_elem_type(i)?;
         let data_address = self.reader.address + self.reader.width.n_bytes() * i;
         Reader::new(
-            self.reader.buffer,
+            self.reader.buffer.shallow_copy(),
             data_address,
             fxb_type,
             bw,
             self.reader.width,
         )
     }
-    pub fn iter(&self) -> ReaderIterator<'de> {
+
+    pub fn iter(&self) -> ReaderIterator<B> {
         ReaderIterator::new(self.clone())
     }
 }