diff --git a/rust/flatbuffers/src/array.rs b/rust/flatbuffers/src/array.rs
new file mode 100644
index 0000000..2ce2e47
--- /dev/null
+++ b/rust/flatbuffers/src/array.rs
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2021 Google Inc. All rights reserved.
+ *
+ * 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
+ *
+ *     http://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::follow::Follow;
+use crate::vector::VectorIter;
+use crate::EndianScalar;
+use core::fmt::{Debug, Formatter, Result};
+use core::marker::PhantomData;
+use core::mem::size_of;
+
+#[derive(Copy, Clone)]
+pub struct Array<'a, T: 'a, const N: usize>(&'a [u8], PhantomData<T>);
+
+impl<'a, T: 'a, const N: usize> Debug for Array<'a, T, N>
+where
+    T: 'a + Follow<'a>,
+    <T as Follow<'a>>::Inner: Debug,
+{
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
+#[allow(clippy::len_without_is_empty)]
+#[allow(clippy::from_over_into)] // TODO(caspern): Go from From to Into.
+impl<'a, T: 'a, const N: usize> Array<'a, T, N> {
+    #[inline(always)]
+    pub fn new(buf: &'a [u8]) -> Self {
+        assert!(size_of::<T>() * N == buf.len());
+
+        Array {
+            0: buf,
+            1: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    pub const fn len(&self) -> usize {
+        N
+    }
+    pub fn as_ptr(&self) -> *const u8 {
+        self.0.as_ptr()
+    }
+}
+
+impl<'a, T: Follow<'a> + 'a, const N: usize> Array<'a, T, N> {
+    #[inline(always)]
+    pub fn get(&self, idx: usize) -> T::Inner {
+        assert!(idx < N);
+        let sz = size_of::<T>();
+        T::follow(self.0, sz * idx)
+    }
+
+    #[inline(always)]
+    pub fn iter(&self) -> VectorIter<'a, T> {
+        VectorIter::from_slice(self.0, self.len())
+    }
+}
+
+impl<'a, T: Follow<'a> + Debug, const N: usize> Into<[T::Inner; N]> for Array<'a, T, N> {
+    #[inline(always)]
+    fn into(self) -> [T::Inner; N] {
+        array_init(|i| self.get(i))
+    }
+}
+
+// TODO(caspern): Implement some future safe version of SafeSliceAccess.
+
+/// Implement Follow for all possible Arrays that have Follow-able elements.
+impl<'a, T: Follow<'a> + 'a, const N: usize> Follow<'a> for Array<'a, T, N> {
+    type Inner = Array<'a, T, N>;
+    #[inline(always)]
+    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        Array::new(&buf[loc..loc + N * size_of::<T>()])
+    }
+}
+
+pub fn emplace_scalar_array<T: EndianScalar, const N: usize>(
+    buf: &mut [u8],
+    loc: usize,
+    src: &[T; N],
+) {
+    let mut buf_ptr = buf[loc..].as_mut_ptr();
+    for item in src.iter() {
+        let item_le = item.to_little_endian();
+        unsafe {
+            core::ptr::copy_nonoverlapping(
+                &item_le as *const T as *const u8,
+                buf_ptr,
+                size_of::<T>(),
+            );
+            buf_ptr = buf_ptr.add(size_of::<T>());
+        }
+    }
+}
+
+impl<'a, T: Follow<'a> + 'a, const N: usize> IntoIterator for Array<'a, T, N> {
+    type Item = T::Inner;
+    type IntoIter = VectorIter<'a, T>;
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+#[inline]
+pub fn array_init<F, T, const N: usize>(mut initializer: F) -> [T; N]
+where
+    F: FnMut(usize) -> T,
+{
+    let mut array: core::mem::MaybeUninit<[T; N]> = core::mem::MaybeUninit::uninit();
+    let mut ptr_i = array.as_mut_ptr() as *mut T;
+
+    unsafe {
+        for i in 0..N {
+            let value_i = initializer(i);
+            ptr_i.write(value_i);
+            ptr_i = ptr_i.add(1);
+        }
+        array.assume_init()
+    }
+}
+
+#[cfg(feature="serialize")]
+impl<'a, T: 'a, const N: usize> serde::ser::Serialize for Array<'a, T, N>
+where
+    T: 'a + Follow<'a>,
+    <T as Follow<'a>>::Inner: serde::ser::Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for element in self.iter() {
+            seq.serialize_element(&element)?;
+        }
+        seq.end()
+    }
+}
diff --git a/rust/flatbuffers/src/builder.rs b/rust/flatbuffers/src/builder.rs
index a3c15f2..8a8b58c 100644
--- a/rust/flatbuffers/src/builder.rs
+++ b/rust/flatbuffers/src/builder.rs
@@ -16,11 +16,13 @@
 
 extern crate smallvec;
 
-use std::cmp::max;
-use std::iter::{DoubleEndedIterator, ExactSizeIterator};
-use std::marker::PhantomData;
-use std::ptr::write_bytes;
-use std::slice::from_raw_parts;
+use core::cmp::max;
+use core::iter::{DoubleEndedIterator, ExactSizeIterator};
+use core::marker::PhantomData;
+use core::ptr::write_bytes;
+use core::slice::from_raw_parts;
+#[cfg(feature = "no_std")]
+use alloc::{vec, vec::Vec};
 
 use crate::endian_scalar::{emplace_scalar, read_scalar_at};
 use crate::primitives::*;
@@ -54,6 +56,7 @@
 
     min_align: usize,
     force_defaults: bool,
+    strings_pool: Vec<WIPOffset<&'fbb str>>,
 
     _phantom: PhantomData<&'fbb ()>,
 }
@@ -61,24 +64,32 @@
 impl<'fbb> FlatBufferBuilder<'fbb> {
     /// Create a FlatBufferBuilder that is ready for writing.
     pub fn new() -> Self {
-        Self::new_with_capacity(0)
+        Self::with_capacity(0)
     }
-
+    #[deprecated(note = "replaced with `with_capacity`", since = "0.8.5")]
+    pub fn new_with_capacity(size: usize) -> Self {
+        Self::with_capacity(size)
+    }
     /// Create a FlatBufferBuilder that is ready for writing, with a
     /// ready-to-use capacity of the provided size.
     ///
     /// The maximum valid value is `FLATBUFFERS_MAX_BUFFER_SIZE`.
-    pub fn new_with_capacity(size: usize) -> Self {
+    pub fn with_capacity(size: usize) -> Self {
+        Self::from_vec(vec![0; size])
+    }
+    /// Create a FlatBufferBuilder that is ready for writing, reusing
+    /// an existing vector.
+    pub fn from_vec(buffer: Vec<u8>) -> Self {
         // we need to check the size here because we create the backing buffer
         // directly, bypassing the typical way of using grow_owned_buf:
         assert!(
-            size <= FLATBUFFERS_MAX_BUFFER_SIZE,
+            buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE,
             "cannot initialize buffer bigger than 2 gigabytes"
         );
-
+        let head = buffer.len();
         FlatBufferBuilder {
-            owned_buf: vec![0u8; size],
-            head: size,
+            owned_buf: buffer,
+            head,
 
             field_locs: Vec::new(),
             written_vtable_revpos: Vec::new(),
@@ -88,6 +99,7 @@
 
             min_align: 0,
             force_defaults: false,
+            strings_pool: Vec::new(),
 
             _phantom: PhantomData,
         }
@@ -121,6 +133,7 @@
         self.finished = false;
 
         self.min_align = 0;
+        self.strings_pool.clear();
     }
 
     /// Destroy the FlatBufferBuilder, returning its internal byte vector
@@ -235,6 +248,43 @@
         WIPOffset::new(o.value())
     }
 
+    #[inline]
+    pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
+        self.assert_not_nested(
+            "create_shared_string can not be called when a table or vector is under construction",
+        );
+
+        // Saves a ref to owned_buf since rust doesnt like us refrencing it
+        // in the binary_search_by code.
+        let buf = &self.owned_buf;
+
+        let found = self.strings_pool.binary_search_by(|offset| {
+            let ptr = offset.value() as usize;
+            // Gets The pointer to the size of the string
+            let str_memory = &buf[buf.len() - ptr..];
+            // Gets the size of the written string from buffer
+            let size =
+                u32::from_le_bytes([str_memory[0], str_memory[1], str_memory[2], str_memory[3]])
+                    as usize;
+            // Size of the string size
+            let string_size: usize = 4;
+            // Fetches actual string bytes from index of string after string size
+            // to the size of string plus string size
+            let iter = str_memory[string_size..size + string_size].iter();
+            // Compares bytes of fetched string and current writable string
+            iter.cloned().cmp(s.bytes())
+        });
+
+        match found {
+            Ok(index) => self.strings_pool[index],
+            Err(index) => {
+                let address = WIPOffset::new(self.create_byte_string(s.as_bytes()).value());
+                self.strings_pool.insert(index, address);
+                address
+            }
+        }
+    }
+
     /// Create a utf8 string.
     ///
     /// The wire format represents this as a zero-terminated byte vector.
@@ -367,11 +417,21 @@
     }
     /// Get the byte slice for the data that has been written after a call to
     /// one of the `finish` functions.
+    /// # Panics
+    /// Panics if the buffer is not finished.
     #[inline]
     pub fn finished_data(&self) -> &[u8] {
         self.assert_finished("finished_bytes cannot be called when the buffer is not yet finished");
         &self.owned_buf[self.head..]
     }
+    /// Returns a mutable view of a finished buffer and location of where the flatbuffer starts.
+    /// Note that modifying the flatbuffer data may corrupt it.
+    /// # Panics
+    /// Panics if the flatbuffer is not finished.
+    #[inline]
+    pub fn mut_finished_buffer(&mut self) -> (&mut [u8], usize) {
+        (&mut self.owned_buf, self.head)
+    }
     /// Assert that a field is present in the just-finished Table.
     ///
     /// This is somewhat low-level and is mostly used by the generated code.
@@ -435,7 +495,7 @@
         // Write the vtable offset, which is the start of any Table.
         // We fill its value later.
         let object_revloc_to_vtable: WIPOffset<VTableWIPOffset> =
-            WIPOffset::new(self.push::<UOffsetT>(0xF0F0_F0F0 as UOffsetT).value());
+            WIPOffset::new(self.push::<UOffsetT>(0xF0F0_F0F0).value());
 
         // Layout of the data this function will create when a new vtable is
         // needed.
@@ -496,39 +556,37 @@
             // serialize every FieldLoc to the vtable:
             for &fl in self.field_locs.iter() {
                 let pos: VOffsetT = (object_revloc_to_vtable.value() - fl.off) as VOffsetT;
-                debug_assert_eq!(
-                    vtfw.get_field_offset(fl.id),
-                    0,
-                    "tried to write a vtable field multiple times"
-                );
                 vtfw.write_field_offset(fl.id, pos);
             }
         }
-        let dup_vt_use = {
-            let this_vt = VTable::init(&self.owned_buf[..], self.head);
-            self.find_duplicate_stored_vtable_revloc(this_vt)
-        };
-
-        let vt_use = match dup_vt_use {
-            Some(n) => {
+        let new_vt_bytes = &self.owned_buf[vt_start_pos..vt_end_pos];
+        let found = self.written_vtable_revpos.binary_search_by(|old_vtable_revpos: &UOffsetT| {
+            let old_vtable_pos = self.owned_buf.len() - *old_vtable_revpos as usize;
+            let old_vtable = VTable::init(&self.owned_buf, old_vtable_pos);
+            new_vt_bytes.cmp(old_vtable.as_bytes())
+        });
+        let final_vtable_revpos = match found {
+            Ok(i) => {
+                // The new vtable is a duplicate so clear it.
                 VTableWriter::init(&mut self.owned_buf[vt_start_pos..vt_end_pos]).clear();
                 self.head += vtable_byte_len;
-                n
+                self.written_vtable_revpos[i]
             }
-            None => {
-                let new_vt_use = self.used_space() as UOffsetT;
-                self.written_vtable_revpos.push(new_vt_use);
-                new_vt_use
+            Err(i) => {
+                // This is a new vtable. Add it to the cache.
+                let new_vt_revpos = self.used_space() as UOffsetT;
+                self.written_vtable_revpos.insert(i, new_vt_revpos);
+                new_vt_revpos
             }
         };
-
-        {
-            let n = self.head + self.used_space() - object_revloc_to_vtable.value() as usize;
-            let saw = read_scalar_at::<UOffsetT>(&self.owned_buf, n);
-            debug_assert_eq!(saw, 0xF0F0_F0F0);
+        // Write signed offset from table to its vtable.
+        let table_pos = self.owned_buf.len() - object_revloc_to_vtable.value() as usize;
+        let tmp_soffset_to_vt = unsafe { read_scalar_at::<UOffsetT>(&self.owned_buf, table_pos) };
+        debug_assert_eq!(tmp_soffset_to_vt, 0xF0F0_F0F0);
+        unsafe {
             emplace_scalar::<SOffsetT>(
-                &mut self.owned_buf[n..n + SIZE_SOFFSET],
-                vt_use as SOffsetT - object_revloc_to_vtable.value() as SOffsetT,
+                &mut self.owned_buf[table_pos..table_pos + SIZE_SOFFSET],
+                final_vtable_revpos as SOffsetT - object_revloc_to_vtable.value() as SOffsetT
             );
         }
 
@@ -537,20 +595,6 @@
         object_revloc_to_vtable
     }
 
-    #[inline]
-    fn find_duplicate_stored_vtable_revloc(&self, needle: VTable) -> Option<UOffsetT> {
-        for &revloc in self.written_vtable_revpos.iter().rev() {
-            let o = VTable::init(
-                &self.owned_buf[..],
-                self.head + self.used_space() - revloc as usize,
-            );
-            if needle == o {
-                return Some(revloc);
-            }
-        }
-        None
-    }
-
     // Only call this when you know it is safe to double the size of the buffer.
     #[inline]
     fn grow_owned_buf(&mut self) {
@@ -685,23 +729,21 @@
         // could be empty (e.g. for empty tables, or for all-default values).
         debug_assert!(
             self.nested,
-            format!(
-                "incorrect FlatBufferBuilder usage: {} must be called while in a nested state",
-                fn_name
-            )
+            "incorrect FlatBufferBuilder usage: {} must be called while in a nested state",
+            fn_name
         );
     }
     #[inline]
     fn assert_not_nested(&self, msg: &'static str) {
-        debug_assert!(!self.nested, msg);
+        debug_assert!(!self.nested, "{}", msg);
     }
     #[inline]
     fn assert_finished(&self, msg: &'static str) {
-        debug_assert!(self.finished, msg);
+        debug_assert!(self.finished, "{}", msg);
     }
     #[inline]
     fn assert_not_finished(&self, msg: &'static str) {
-        debug_assert!(!self.finished, msg);
+        debug_assert!(!self.finished, "{}", msg);
     }
 }
 
@@ -725,6 +767,6 @@
 
 impl<'fbb> Default for FlatBufferBuilder<'fbb> {
     fn default() -> Self {
-        Self::new_with_capacity(0)
+        Self::with_capacity(0)
     }
 }
diff --git a/rust/flatbuffers/src/endian_scalar.rs b/rust/flatbuffers/src/endian_scalar.rs
index df0b384..5f50cf1 100644
--- a/rust/flatbuffers/src/endian_scalar.rs
+++ b/rust/flatbuffers/src/endian_scalar.rs
@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#![allow(clippy::wrong_self_convention)]
 
-use std::mem::size_of;
+use core::mem::size_of;
 
 /// Trait for values that must be stored in little-endian byte order, but
 /// might be represented in memory as big-endian. Every type that implements
@@ -148,32 +149,36 @@
 
 /// Place an EndianScalar into the provided mutable byte slice. Performs
 /// endian conversion, if necessary.
+/// # Safety
+/// Caller must ensure `s.len() > size_of::<T>()`
+/// and `x` does not overlap with `s`.
 #[inline]
-pub fn emplace_scalar<T: EndianScalar>(s: &mut [u8], x: T) {
-    let sz = size_of::<T>();
-    let mut_ptr = (&mut s[..sz]).as_mut_ptr() as *mut T;
-    let val = x.to_little_endian();
-    unsafe {
-        *mut_ptr = val;
-    }
+pub unsafe fn emplace_scalar<T: EndianScalar>(s: &mut [u8], x: T) {
+    let x_le = x.to_little_endian();
+    core::ptr::copy_nonoverlapping(
+        &x_le as *const T as *const u8,
+        s.as_mut_ptr() as *mut u8,
+        size_of::<T>(),
+    );
 }
 
 /// Read an EndianScalar from the provided byte slice at the specified location.
 /// Performs endian conversion, if necessary.
+/// # Safety
+/// Caller must ensure `s.len() > loc + size_of::<T>()`.
 #[inline]
-pub fn read_scalar_at<T: EndianScalar>(s: &[u8], loc: usize) -> T {
-    let buf = &s[loc..loc + size_of::<T>()];
-    read_scalar(buf)
+pub unsafe fn read_scalar_at<T: EndianScalar>(s: &[u8], loc: usize) -> T {
+    read_scalar(&s[loc..])
 }
 
 /// Read an EndianScalar from the provided byte slice. Performs endian
 /// conversion, if necessary.
+/// # Safety
+/// Caller must ensure `s.len() > size_of::<T>()`.
 #[inline]
-pub fn read_scalar<T: EndianScalar>(s: &[u8]) -> T {
-    let sz = size_of::<T>();
-
-    let p = (&s[..sz]).as_ptr() as *const T;
-    let x = unsafe { *p };
-
-    x.from_little_endian()
+pub unsafe fn read_scalar<T: EndianScalar>(s: &[u8]) -> T {
+    let mut mem = core::mem::MaybeUninit::<T>::uninit();
+    // Since [u8] has alignment 1, we copy it into T which may have higher alignment.
+    core::ptr::copy_nonoverlapping(s.as_ptr(), mem.as_mut_ptr() as *mut u8, size_of::<T>());
+    mem.assume_init().from_little_endian()
 }
diff --git a/rust/flatbuffers/src/follow.rs b/rust/flatbuffers/src/follow.rs
index 8dd70da..d1d6483 100644
--- a/rust/flatbuffers/src/follow.rs
+++ b/rust/flatbuffers/src/follow.rs
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 /// Follow is a trait that allows us to access FlatBuffers in a declarative,
 /// type safe, and fast way. They compile down to almost no code (after
@@ -27,16 +27,9 @@
 /// Writing a new Follow implementation primarily involves deciding whether
 /// you want to return data (of the type Self::Inner) or do you want to
 /// continue traversing the FlatBuffer.
-pub trait Follow<'a> {
+pub trait Follow<'buf> {
     type Inner;
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner;
-}
-
-/// Execute a follow as a top-level function.
-#[allow(dead_code)]
-#[inline]
-pub fn lifted_follow<'a, T: Follow<'a>>(buf: &'a [u8], loc: usize) -> T::Inner {
-    T::follow(buf, loc)
+    fn follow(buf: &'buf [u8], loc: usize) -> Self::Inner;
 }
 
 /// FollowStart wraps a Follow impl in a struct type. This can make certain
diff --git a/rust/flatbuffers/src/get_root.rs b/rust/flatbuffers/src/get_root.rs
new file mode 100644
index 0000000..3305efa
--- /dev/null
+++ b/rust/flatbuffers/src/get_root.rs
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * 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
+ *
+ *     http://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::{
+    Follow, ForwardsUOffset, InvalidFlatbuffer, SkipSizePrefix, Verifiable, Verifier,
+    VerifierOptions,
+};
+
+/// Gets the root of the Flatbuffer, verifying it first with default options.
+/// Note that verification is an experimental feature and may not be maximally performant or
+/// catch every error (though that is the goal). See the `_unchecked` variants for previous
+/// behavior.
+pub fn root<'buf, T>(data: &'buf [u8]) -> Result<T::Inner, InvalidFlatbuffer>
+where
+    T: 'buf + Follow<'buf> + Verifiable,
+{
+    let opts = VerifierOptions::default();
+    root_with_opts::<T>(&opts, data)
+}
+
+#[inline]
+/// Gets the root of the Flatbuffer, verifying it first with given options.
+/// Note that verification is an experimental feature and may not be maximally performant or
+/// catch every error (though that is the goal). See the `_unchecked` variants for previous
+/// behavior.
+pub fn root_with_opts<'opts, 'buf, T>(
+    opts: &'opts VerifierOptions,
+    data: &'buf [u8],
+) -> Result<T::Inner, InvalidFlatbuffer>
+where
+    T: 'buf + Follow<'buf> + Verifiable,
+{
+    let mut v = Verifier::new(opts, data);
+    <ForwardsUOffset<T>>::run_verifier(&mut v, 0)?;
+    Ok(unsafe { root_unchecked::<T>(data) })
+}
+
+#[inline]
+/// Gets the root of a size prefixed Flatbuffer, verifying it first with default options.
+/// Note that verification is an experimental feature and may not be maximally performant or
+/// catch every error (though that is the goal). See the `_unchecked` variants for previous
+/// behavior.
+pub fn size_prefixed_root<'buf, T>(data: &'buf [u8]) -> Result<T::Inner, InvalidFlatbuffer>
+where
+    T: 'buf + Follow<'buf> + Verifiable,
+{
+    let opts = VerifierOptions::default();
+    size_prefixed_root_with_opts::<T>(&opts, data)
+}
+
+#[inline]
+/// Gets the root of a size prefixed Flatbuffer, verifying it first with given options.
+/// Note that verification is an experimental feature and may not be maximally performant or
+/// catch every error (though that is the goal). See the `_unchecked` variants for previous
+/// behavior.
+pub fn size_prefixed_root_with_opts<'opts, 'buf, T>(
+    opts: &'opts VerifierOptions,
+    data: &'buf [u8],
+) -> Result<T::Inner, InvalidFlatbuffer>
+where
+    T: 'buf + Follow<'buf> + Verifiable,
+{
+    let mut v = Verifier::new(opts, data);
+    <SkipSizePrefix<ForwardsUOffset<T>>>::run_verifier(&mut v, 0)?;
+    Ok(unsafe { size_prefixed_root_unchecked::<T>(data) })
+}
+
+#[inline]
+/// Gets root for a trusted Flatbuffer.
+/// # Safety
+/// Flatbuffers accessors do not perform validation checks before accessing. Unlike the other
+/// `root` functions, this does not validate the flatbuffer before returning the accessor. Users
+/// must trust `data` contains a valid flatbuffer (e.g. b/c it was built by your software). Reading
+/// unchecked buffers may cause panics or even UB.
+pub unsafe fn root_unchecked<'buf, T>(data: &'buf [u8]) -> T::Inner
+where
+    T: Follow<'buf> + 'buf,
+{
+    <ForwardsUOffset<T>>::follow(data, 0)
+}
+
+#[inline]
+/// Gets root for a trusted, size prefixed, Flatbuffer.
+/// # Safety
+/// Flatbuffers accessors do not perform validation checks before accessing. Unlike the other
+/// `root` functions, this does not validate the flatbuffer before returning the accessor. Users
+/// must trust `data` contains a valid flatbuffer (e.g. b/c it was built by your software). Reading
+/// unchecked buffers may cause panics or even UB.
+pub unsafe fn size_prefixed_root_unchecked<'buf, T>(data: &'buf [u8]) -> T::Inner
+where
+    T: Follow<'buf> + 'buf,
+{
+    <SkipSizePrefix<ForwardsUOffset<T>>>::follow(data, 0)
+}
diff --git a/rust/flatbuffers/src/lib.rs b/rust/flatbuffers/src/lib.rs
index 3abd33b..bc114e6 100644
--- a/rust/flatbuffers/src/lib.rs
+++ b/rust/flatbuffers/src/lib.rs
@@ -19,26 +19,34 @@
 //! A library for memory-efficient serialization of data.
 //!
 //! This crate provides runtime support for the FlatBuffers format in the Rust programming language.
-//! To use this crate, first generate code with the `flatc` compiler, as described here: https://google.github.io/flatbuffers/
+//! To use this crate, first generate code with the `flatc` compiler, as described here: <https://google.github.io/flatbuffers/>
 //! Then, include that code into your project.
 //! Finally, add this crate to your `Cargo.toml`.
 //!
 //! At this time, Rust support is experimental, and APIs may change between minor versions.
 //!
-//! At this time, to generate Rust code, you will need the latest `master` version of `flatc`, available from here: https://github.com/google/flatbuffers
+//! At this time, to generate Rust code, you will need the latest `master` version of `flatc`, available from here: <https://github.com/google/flatbuffers>
 //! (On OSX, you can install FlatBuffers from `HEAD` with the Homebrew package manager.)
 
+#![cfg_attr(feature = "no_std", no_std)]
+
+#[cfg(feature = "no_std")]
+extern crate alloc;
+
+mod array;
 mod builder;
 mod endian_scalar;
 mod follow;
+mod get_root;
 mod primitives;
 mod push;
 mod table;
 mod vector;
+mod verifier;
 mod vtable;
 mod vtable_writer;
 
-pub use bitflags;
+pub use crate::array::{array_init, emplace_scalar_array, Array};
 pub use crate::builder::FlatBufferBuilder;
 pub use crate::endian_scalar::{
     byte_swap_f32, byte_swap_f64, emplace_scalar, read_scalar, read_scalar_at, EndianScalar,
@@ -46,9 +54,15 @@
 pub use crate::follow::{Follow, FollowStart};
 pub use crate::primitives::*;
 pub use crate::push::Push;
-pub use crate::table::{buffer_has_identifier, get_root, get_size_prefixed_root, Table};
+pub use crate::table::{buffer_has_identifier, Table};
 pub use crate::vector::{follow_cast_ref, SafeSliceAccess, Vector, VectorIter};
+pub use crate::verifier::{
+    ErrorTraceDetail, InvalidFlatbuffer, SimpleToVerifyInSlice, Verifiable, Verifier,
+    VerifierOptions,
+};
 pub use crate::vtable::field_index_to_field_offset;
+pub use bitflags;
+pub use get_root::*;
 
 // TODO(rw): Unify `create_vector` and `create_vector_direct` by using
 //           `Into<Vector<...>>`.
diff --git a/rust/flatbuffers/src/primitives.rs b/rust/flatbuffers/src/primitives.rs
index 350e984..72764b2 100644
--- a/rust/flatbuffers/src/primitives.rs
+++ b/rust/flatbuffers/src/primitives.rs
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-use std::marker::PhantomData;
-use std::mem::size_of;
-use std::ops::Deref;
+use core::marker::PhantomData;
+use core::mem::size_of;
+use core::ops::Deref;
 
 use crate::endian_scalar::{emplace_scalar, read_scalar, read_scalar_at};
 use crate::follow::Follow;
@@ -93,6 +93,8 @@
     }
 }
 
+impl<T> Eq for WIPOffset<T> {}
+
 impl<T> PartialEq for WIPOffset<T> {
     fn eq(&self, o: &WIPOffset<T>) -> bool {
         self.value() == o.value()
@@ -135,7 +137,9 @@
     #[inline(always)]
     fn push(&self, dst: &mut [u8], rest: &[u8]) {
         let n = (SIZE_UOFFSET + rest.len() - self.value() as usize) as UOffsetT;
-        emplace_scalar::<UOffsetT>(dst, n);
+        unsafe {
+            emplace_scalar::<UOffsetT>(dst, n);
+        }
     }
 }
 
@@ -177,7 +181,7 @@
     #[inline(always)]
     fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         let slice = &buf[loc..loc + SIZE_UOFFSET];
-        let off = read_scalar::<u32>(slice) as usize;
+        let off = unsafe { read_scalar::<u32>(slice) as usize };
         T::follow(buf, loc + off)
     }
 }
@@ -198,7 +202,7 @@
     #[inline(always)]
     fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         let slice = &buf[loc..loc + SIZE_VOFFSET];
-        let off = read_scalar::<VOffsetT>(slice) as usize;
+        let off = unsafe { read_scalar::<VOffsetT>(slice) as usize };
         T::follow(buf, loc + off)
     }
 }
@@ -228,7 +232,7 @@
     #[inline(always)]
     fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         let slice = &buf[loc..loc + SIZE_SOFFSET];
-        let off = read_scalar::<SOffsetT>(slice);
+        let off = unsafe { read_scalar::<SOffsetT>(slice) };
         T::follow(buf, (loc as SOffsetT - off) as usize)
     }
 }
@@ -291,7 +295,7 @@
     type Inner = bool;
     #[inline(always)]
     fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        read_scalar_at::<u8>(buf, loc) != 0
+        unsafe { read_scalar_at::<u8>(buf, loc) != 0 }
     }
 }
 
@@ -306,7 +310,7 @@
             type Inner = $ty;
             #[inline(always)]
             fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-                read_scalar_at::<$ty>(buf, loc)
+                unsafe { read_scalar_at::<$ty>(buf, loc) }
             }
         }
     };
diff --git a/rust/flatbuffers/src/push.rs b/rust/flatbuffers/src/push.rs
index c461372..8bb8fe9 100644
--- a/rust/flatbuffers/src/push.rs
+++ b/rust/flatbuffers/src/push.rs
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-use std::cmp::max;
-use std::mem::{align_of, size_of};
+use core::cmp::max;
+use core::mem::{align_of, size_of};
 
 use crate::endian_scalar::emplace_scalar;
 
@@ -61,7 +61,9 @@
 
             #[inline]
             fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-                emplace_scalar::<$ty>(dst, *self);
+                unsafe {
+                    emplace_scalar::<$ty>(dst, *self);
+                }
             }
         }
     };
diff --git a/rust/flatbuffers/src/table.rs b/rust/flatbuffers/src/table.rs
index 46728cd..cfb8559 100644
--- a/rust/flatbuffers/src/table.rs
+++ b/rust/flatbuffers/src/table.rs
@@ -56,14 +56,6 @@
 }
 
 #[inline]
-pub fn get_root<'a, T: Follow<'a> + 'a>(data: &'a [u8]) -> T::Inner {
-    <ForwardsUOffset<T>>::follow(data, 0)
-}
-#[inline]
-pub fn get_size_prefixed_root<'a, T: Follow<'a> + 'a>(data: &'a [u8]) -> T::Inner {
-    <SkipSizePrefix<ForwardsUOffset<T>>>::follow(data, 0)
-}
-#[inline]
 pub fn buffer_has_identifier(data: &[u8], ident: &str, size_prefixed: bool) -> bool {
     assert_eq!(ident.len(), FILE_IDENTIFIER_LENGTH);
 
diff --git a/rust/flatbuffers/src/vector.rs b/rust/flatbuffers/src/vector.rs
index 5236ea1..da04ef6 100644
--- a/rust/flatbuffers/src/vector.rs
+++ b/rust/flatbuffers/src/vector.rs
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-use std::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator};
-use std::marker::PhantomData;
-use std::mem::size_of;
-use std::slice::from_raw_parts;
-use std::str::from_utf8_unchecked;
-use std::fmt::{Debug, Result, Formatter};
+use core::fmt::{Debug, Formatter, Result};
+use core::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator};
+use core::marker::PhantomData;
+use core::mem::size_of;
+use core::slice::from_raw_parts;
+use core::str::from_utf8_unchecked;
 
 use crate::endian_scalar::read_scalar_at;
 #[cfg(target_endian = "little")]
@@ -29,17 +29,28 @@
 
 pub struct Vector<'a, T: 'a>(&'a [u8], usize, PhantomData<T>);
 
+impl<'a, T: 'a> Default for Vector<'a, T> {
+    fn default() -> Self {
+        // Static, length 0 vector.
+        // Note that derived default causes UB due to issues in read_scalar_at /facepalm.
+        Self(
+            &[0; core::mem::size_of::<UOffsetT>()],
+            0,
+            Default::default(),
+        )
+    }
+}
+
 impl<'a, T> Debug for Vector<'a, T>
 where
     T: 'a + Follow<'a>,
-    <T as Follow<'a>>::Inner : Debug
+    <T as Follow<'a>>::Inner: Debug,
 {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.debug_list().entries(self.iter()).finish()
     }
 }
 
-
 // We cannot use derive for these two impls, as it would only implement Copy
 // and Clone for `T: Copy` and `T: Clone` respectively. However `Vector<'a, T>`
 // can always be copied, no matter that `T` you have.
@@ -62,7 +73,7 @@
 
     #[inline(always)]
     pub fn len(&self) -> usize {
-        read_scalar_at::<UOffsetT>(&self.0, self.1) as usize
+        unsafe { read_scalar_at::<UOffsetT>(self.0, self.1) as usize }
     }
     #[inline(always)]
     pub fn is_empty(&self) -> bool {
@@ -73,7 +84,7 @@
 impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
     #[inline(always)]
     pub fn get(&self, idx: usize) -> T::Inner {
-        debug_assert!(idx < read_scalar_at::<u32>(&self.0, self.1) as usize);
+        assert!(idx < self.len() as usize);
         let sz = size_of::<T>();
         debug_assert!(sz > 0);
         T::follow(self.0, self.1 as usize + SIZE_UOFFSET + sz * idx)
@@ -81,7 +92,7 @@
 
     #[inline(always)]
     pub fn iter(&self) -> VectorIter<'a, T> {
-        VectorIter::new(*self)
+        VectorIter::from_vector(*self)
     }
 }
 
@@ -92,7 +103,7 @@
         let loc = self.1;
         let sz = size_of::<T>();
         debug_assert!(sz > 0);
-        let len = read_scalar_at::<UOffsetT>(&buf, loc) as usize;
+        let len = unsafe { read_scalar_at::<UOffsetT>(buf, loc) } as usize;
         let data_buf = &buf[loc + SIZE_UOFFSET..loc + SIZE_UOFFSET + len * sz];
         let ptr = data_buf.as_ptr() as *const T;
         let s: &'a [T] = unsafe { from_raw_parts(ptr, len) };
@@ -104,6 +115,8 @@
 impl SafeSliceAccess for i8 {}
 impl SafeSliceAccess for bool {}
 
+// TODO(caspern): Get rid of this. Conditional compliation is unnecessary complexity.
+// Vectors of primitives just don't work on big endian machines!!!
 #[cfg(target_endian = "little")]
 mod le_safe_slice_impls {
     impl super::SafeSliceAccess for u16 {}
@@ -131,7 +144,7 @@
 impl<'a> Follow<'a> for &'a str {
     type Inner = &'a str;
     fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let len = read_scalar_at::<UOffsetT>(&buf, loc) as usize;
+        let len = unsafe { read_scalar_at::<UOffsetT>(buf, loc) } as usize;
         let slice = &buf[loc + SIZE_UOFFSET..loc + SIZE_UOFFSET + len];
         unsafe { from_utf8_unchecked(slice) }
     }
@@ -141,7 +154,7 @@
 fn follow_slice_helper<T>(buf: &[u8], loc: usize) -> &[T] {
     let sz = size_of::<T>();
     debug_assert!(sz > 0);
-    let len = read_scalar_at::<UOffsetT>(&buf, loc) as usize;
+    let len = unsafe { read_scalar_at::<UOffsetT>(buf, loc) as usize };
     let data_buf = &buf[loc + SIZE_UOFFSET..loc + SIZE_UOFFSET + len * sz];
     let ptr = data_buf.as_ptr() as *const T;
     let s: &[T] = unsafe { from_raw_parts(ptr, len) };
@@ -176,7 +189,7 @@
 
 impl<'a, T: 'a> VectorIter<'a, T> {
     #[inline]
-    pub fn new(inner: Vector<'a, T>) -> Self {
+    pub fn from_vector(inner: Vector<'a, T>) -> Self {
         VectorIter {
             buf: inner.0,
             // inner.1 is the location of the data for the vector.
@@ -187,6 +200,16 @@
             phantom: PhantomData,
         }
     }
+
+    #[inline]
+    pub fn from_slice(buf: &'a [u8], items_num: usize) -> Self {
+        VectorIter {
+            buf,
+            loc: 0,
+            remaining: items_num,
+            phantom: PhantomData,
+        }
+    }
 }
 
 impl<'a, T: Follow<'a> + 'a> Clone for VectorIter<'a, T> {
@@ -285,3 +308,22 @@
         self.iter()
     }
 }
+
+#[cfg(feature="serialize")]
+impl<'a, T> serde::ser::Serialize for Vector<'a, T>
+where
+    T: 'a + Follow<'a>,
+    <T as Follow<'a>>::Inner: serde::ser::Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for element in self {
+            seq.serialize_element(&element)?;
+        }
+        seq.end()
+    }
+}
diff --git a/rust/flatbuffers/src/verifier.rs b/rust/flatbuffers/src/verifier.rs
new file mode 100644
index 0000000..d5e31df
--- /dev/null
+++ b/rust/flatbuffers/src/verifier.rs
@@ -0,0 +1,574 @@
+#[cfg(feature = "no_std")]
+use alloc::vec::Vec;
+use core::ops::Range;
+use core::option::Option;
+use crate::follow::Follow;
+use crate::{ForwardsUOffset, SOffsetT, SkipSizePrefix, UOffsetT, VOffsetT, Vector, SIZE_UOFFSET};
+
+#[cfg(feature="no_std")]
+extern crate thiserror_core2 as thiserror;
+use thiserror::Error;
+
+/// Traces the location of data errors. Not populated for Dos detecting errors.
+/// Useful for MissingRequiredField and Utf8Error in particular, though
+/// the other errors should not be producible by correct flatbuffers implementations.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ErrorTraceDetail {
+    VectorElement {
+        index: usize,
+        position: usize,
+    },
+    TableField {
+        field_name: &'static str,
+        position: usize,
+    },
+    UnionVariant {
+        variant: &'static str,
+        position: usize,
+    },
+}
+#[derive(PartialEq, Eq, Default, Debug, Clone)]
+pub struct ErrorTrace(Vec<ErrorTraceDetail>);
+impl core::convert::AsRef<[ErrorTraceDetail]> for ErrorTrace {
+    #[inline]
+    fn as_ref(&self) -> &[ErrorTraceDetail] {
+        &self.0
+    }
+}
+
+/// Describes how a flatuffer is invalid and, for data errors, roughly where. No extra tracing
+/// information is given for DoS detecting errors since it will probably be a lot.
+#[derive(Clone, Error, Debug, PartialEq, Eq)]
+pub enum InvalidFlatbuffer {
+    #[error("Missing required field `{required}`.\n{error_trace}")]
+    MissingRequiredField {
+        required: &'static str,
+        error_trace: ErrorTrace,
+    },
+    #[error(
+        "Union exactly one of union discriminant (`{field_type}`) and value \
+             (`{field}`) are present.\n{error_trace}"
+    )]
+    InconsistentUnion {
+        field: &'static str,
+        field_type: &'static str,
+        error_trace: ErrorTrace,
+    },
+    #[error("Utf8 error for string in {range:?}: {error}\n{error_trace}")]
+    Utf8Error {
+        #[source]
+        error: core::str::Utf8Error,
+        range: Range<usize>,
+        error_trace: ErrorTrace,
+    },
+    #[error("String in range [{}, {}) is missing its null terminator.\n{error_trace}",
+            range.start, range.end)]
+    MissingNullTerminator {
+        range: Range<usize>,
+        error_trace: ErrorTrace,
+    },
+    #[error("Type `{unaligned_type}` at position {position} is unaligned.\n{error_trace}")]
+    Unaligned {
+        position: usize,
+        unaligned_type: &'static str,
+        error_trace: ErrorTrace,
+    },
+    #[error("Range [{}, {}) is out of bounds.\n{error_trace}", range.start, range.end)]
+    RangeOutOfBounds {
+        range: Range<usize>,
+        error_trace: ErrorTrace,
+    },
+    #[error(
+        "Signed offset at position {position} has value {soffset} which points out of bounds.\
+             \n{error_trace}"
+    )]
+    SignedOffsetOutOfBounds {
+        soffset: SOffsetT,
+        position: usize,
+        error_trace: ErrorTrace,
+    },
+    // Dos detecting errors. These do not get error traces since it will probably be very large.
+    #[error("Too many tables.")]
+    TooManyTables,
+    #[error("Apparent size too large.")]
+    ApparentSizeTooLarge,
+    #[error("Nested table depth limit reached.")]
+    DepthLimitReached,
+}
+
+impl core::fmt::Display for ErrorTrace {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use ErrorTraceDetail::*;
+        for e in self.0.iter() {
+            match e {
+                VectorElement { index, position } => {
+                    writeln!(
+                        f,
+                        "\twhile verifying vector element {:?} at position {:?}",
+                        index, position
+                    )?;
+                }
+                TableField {
+                    field_name,
+                    position,
+                } => {
+                    writeln!(
+                        f,
+                        "\twhile verifying table field `{}` at position {:?}",
+                        field_name, position
+                    )?;
+                }
+                UnionVariant { variant, position } => {
+                    writeln!(
+                        f,
+                        "\t while verifying union variant `{}` at position {:?}",
+                        variant, position
+                    )?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+pub type Result<T> = core::result::Result<T, InvalidFlatbuffer>;
+
+impl InvalidFlatbuffer {
+    fn new_range_oob<T>(start: usize, end: usize) -> Result<T> {
+        Err(Self::RangeOutOfBounds {
+            range: Range { start, end },
+            error_trace: Default::default(),
+        })
+    }
+    fn new_inconsistent_union<T>(field: &'static str, field_type: &'static str) -> Result<T> {
+        Err(Self::InconsistentUnion {
+            field,
+            field_type,
+            error_trace: Default::default(),
+        })
+    }
+    fn new_missing_required<T>(required: &'static str) -> Result<T> {
+        Err(Self::MissingRequiredField {
+            required,
+            error_trace: Default::default(),
+        })
+    }
+}
+
+/// Records the path to the verifier detail if the error is a data error and not a DoS error.
+fn append_trace<T>(mut res: Result<T>, d: ErrorTraceDetail) -> Result<T> {
+    if let Err(e) = res.as_mut() {
+        use InvalidFlatbuffer::*;
+        if let MissingRequiredField { error_trace, .. }
+        | Unaligned { error_trace, .. }
+        | RangeOutOfBounds { error_trace, .. }
+        | InconsistentUnion { error_trace, .. }
+        | Utf8Error { error_trace, .. }
+        | MissingNullTerminator { error_trace, .. }
+        | SignedOffsetOutOfBounds { error_trace, .. } = e
+        {
+            error_trace.0.push(d)
+        }
+    }
+    res
+}
+
+/// Adds a TableField trace detail if `res` is a data error.
+fn trace_field<T>(res: Result<T>, field_name: &'static str, position: usize) -> Result<T> {
+    append_trace(
+        res,
+        ErrorTraceDetail::TableField {
+            field_name,
+            position,
+        },
+    )
+}
+/// Adds a TableField trace detail if `res` is a data error.
+fn trace_elem<T>(res: Result<T>, index: usize, position: usize) -> Result<T> {
+    append_trace(res, ErrorTraceDetail::VectorElement { index, position })
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VerifierOptions {
+    /// Maximum depth of nested tables allowed in a valid flatbuffer.
+    pub max_depth: usize,
+    /// Maximum number of tables allowed in a valid flatbuffer.
+    pub max_tables: usize,
+    /// Maximum "apparent" size of the message if the Flatbuffer object DAG is expanded into a
+    /// tree.
+    pub max_apparent_size: usize,
+    /// Ignore errors where a string is missing its null terminator.
+    /// This is mostly a problem if the message will be sent to a client using old c-strings.
+    pub ignore_missing_null_terminator: bool,
+    // probably want an option to ignore utf8 errors since strings come from c++
+    // options to error un-recognized enums and unions? possible footgun.
+    // Ignore nested flatbuffers, etc?
+}
+impl Default for VerifierOptions {
+    fn default() -> Self {
+        Self {
+            max_depth: 64,
+            max_tables: 1_000_000,
+            // size_ might do something different.
+            max_apparent_size: 1 << 31,
+            ignore_missing_null_terminator: false,
+        }
+    }
+}
+
+/// Carries the verification state. Should not be reused between tables.
+#[derive(Debug)]
+pub struct Verifier<'opts, 'buf> {
+    buffer: &'buf [u8],
+    opts: &'opts VerifierOptions,
+    depth: usize,
+    num_tables: usize,
+    apparent_size: usize,
+}
+impl<'opts, 'buf> Verifier<'opts, 'buf> {
+    pub fn new(opts: &'opts VerifierOptions, buffer: &'buf [u8]) -> Self {
+        Self {
+            opts,
+            buffer,
+            depth: 0,
+            num_tables: 0,
+            apparent_size: 0,
+        }
+    }
+    /// Resets verifier internal state.
+    #[inline]
+    pub fn reset(&mut self) {
+        self.depth = 0;
+        self.num_tables = 0;
+        self.num_tables = 0;
+    }
+    /// Checks `pos` is aligned to T's alignment. This does not mean `buffer[pos]` is aligned w.r.t
+    /// memory since `buffer: &[u8]` has alignment 1.
+    ///
+    /// ### WARNING
+    /// This does not work for flatbuffers-structs as they have alignment 1 according to
+    /// `core::mem::align_of` but are meant to have higher alignment within a Flatbuffer w.r.t.
+    /// `buffer[0]`. TODO(caspern).
+    #[inline]
+    fn is_aligned<T>(&self, pos: usize) -> Result<()> {
+        if pos % core::mem::align_of::<T>() == 0 {
+            Ok(())
+        } else {
+            Err(InvalidFlatbuffer::Unaligned {
+                unaligned_type: core::any::type_name::<T>(),
+                position: pos,
+                error_trace: Default::default(),
+            })
+        }
+    }
+    #[inline]
+    fn range_in_buffer(&mut self, pos: usize, size: usize) -> Result<()> {
+        let end = pos.saturating_add(size);
+        if end > self.buffer.len() {
+            return InvalidFlatbuffer::new_range_oob(pos, end);
+        }
+        self.apparent_size += size;
+        if self.apparent_size > self.opts.max_apparent_size {
+            return Err(InvalidFlatbuffer::ApparentSizeTooLarge);
+        }
+        Ok(())
+    }
+    /// Check that there really is a T in there.
+    #[inline]
+    pub fn in_buffer<T>(&mut self, pos: usize) -> Result<()> {
+        self.is_aligned::<T>(pos)?;
+        self.range_in_buffer(pos, core::mem::size_of::<T>())
+    }
+    #[inline]
+    fn get_u16(&mut self, pos: usize) -> Result<u16> {
+        self.in_buffer::<u16>(pos)?;
+        Ok(u16::from_le_bytes([self.buffer[pos], self.buffer[pos + 1]]))
+    }
+    #[inline]
+    fn get_uoffset(&mut self, pos: usize) -> Result<UOffsetT> {
+        self.in_buffer::<u32>(pos)?;
+        Ok(u32::from_le_bytes([
+            self.buffer[pos],
+            self.buffer[pos + 1],
+            self.buffer[pos + 2],
+            self.buffer[pos + 3],
+        ]))
+    }
+    #[inline]
+    fn deref_soffset(&mut self, pos: usize) -> Result<usize> {
+        self.in_buffer::<SOffsetT>(pos)?;
+        let offset = SOffsetT::from_le_bytes([
+            self.buffer[pos],
+            self.buffer[pos + 1],
+            self.buffer[pos + 2],
+            self.buffer[pos + 3],
+        ]);
+
+        // signed offsets are subtracted.
+        let derefed = if offset > 0 {
+            pos.checked_sub(offset.abs() as usize)
+        } else {
+            pos.checked_add(offset.abs() as usize)
+        };
+        if let Some(x) = derefed {
+            if x < self.buffer.len() {
+                return Ok(x);
+            }
+        }
+        Err(InvalidFlatbuffer::SignedOffsetOutOfBounds {
+            soffset: offset,
+            position: pos,
+            error_trace: Default::default(),
+        })
+    }
+    #[inline]
+    pub fn visit_table<'ver>(
+        &'ver mut self,
+        table_pos: usize,
+    ) -> Result<TableVerifier<'ver, 'opts, 'buf>> {
+        let vtable_pos = self.deref_soffset(table_pos)?;
+        let vtable_len = self.get_u16(vtable_pos)? as usize;
+        self.is_aligned::<VOffsetT>(vtable_pos.saturating_add(vtable_len))?; // i.e. vtable_len is even.
+        self.range_in_buffer(vtable_pos, vtable_len)?;
+        // Check bounds.
+        self.num_tables += 1;
+        if self.num_tables > self.opts.max_tables {
+            return Err(InvalidFlatbuffer::TooManyTables);
+        }
+        self.depth += 1;
+        if self.depth > self.opts.max_depth {
+            return Err(InvalidFlatbuffer::DepthLimitReached);
+        }
+        Ok(TableVerifier {
+            pos: table_pos,
+            vtable: vtable_pos,
+            vtable_len,
+            verifier: self,
+        })
+    }
+
+    /// Runs the union variant's type's verifier assuming the variant is at the given position,
+    /// tracing the error.
+    pub fn verify_union_variant<T: Verifiable>(
+        &mut self,
+        variant: &'static str,
+        position: usize,
+    ) -> Result<()> {
+        let res = T::run_verifier(self, position);
+        append_trace(res, ErrorTraceDetail::UnionVariant { variant, position })
+    }
+}
+
+// Cache table metadata in usize so we don't have to cast types or jump around so much.
+// We will visit every field anyway.
+pub struct TableVerifier<'ver, 'opts, 'buf> {
+    // Absolute position of table in buffer
+    pos: usize,
+    // Absolute position of vtable in buffer.
+    vtable: usize,
+    // Length of vtable.
+    vtable_len: usize,
+    // Verifier struct which holds the surrounding state and options.
+    verifier: &'ver mut Verifier<'opts, 'buf>,
+}
+impl<'ver, 'opts, 'buf> TableVerifier<'ver, 'opts, 'buf> {
+    fn deref(&mut self, field: VOffsetT) -> Result<Option<usize>> {
+        let field = field as usize;
+        if field < self.vtable_len {
+            let field_offset = self.verifier.get_u16(self.vtable.saturating_add(field))?;
+            if field_offset > 0 {
+                // Field is present.
+                let field_pos = self.pos.saturating_add(field_offset as usize);
+                return Ok(Some(field_pos));
+            }
+        }
+        Ok(None)
+    }
+
+    #[inline]
+    pub fn visit_field<T: Verifiable>(
+        mut self,
+        field_name: &'static str,
+        field: VOffsetT,
+        required: bool,
+    ) -> Result<Self> {
+        if let Some(field_pos) = self.deref(field)? {
+            trace_field(
+                T::run_verifier(self.verifier, field_pos),
+                field_name,
+                field_pos,
+            )?;
+            return Ok(self);
+        }
+        if required {
+            InvalidFlatbuffer::new_missing_required(field_name)
+        } else {
+            Ok(self)
+        }
+    }
+    #[inline]
+    /// Union verification is complicated. The schemas passes this function the metadata of the
+    /// union's key (discriminant) and value fields, and a callback. The function verifies and
+    /// reads the key, then invokes the callback to perform data-dependent verification.
+    pub fn visit_union<Key, UnionVerifier>(
+        mut self,
+        key_field_name: &'static str,
+        key_field_voff: VOffsetT,
+        val_field_name: &'static str,
+        val_field_voff: VOffsetT,
+        required: bool,
+        verify_union: UnionVerifier,
+    ) -> Result<Self>
+    where
+        Key: Follow<'buf> + Verifiable,
+        UnionVerifier:
+            (core::ops::FnOnce(<Key as Follow<'buf>>::Inner, &mut Verifier, usize) -> Result<()>),
+        // NOTE: <Key as Follow<'buf>>::Inner == Key
+    {
+        // TODO(caspern): how to trace vtable errors?
+        let val_pos = self.deref(val_field_voff)?;
+        let key_pos = self.deref(key_field_voff)?;
+        match (key_pos, val_pos) {
+            (None, None) => {
+                if required {
+                    InvalidFlatbuffer::new_missing_required(val_field_name)
+                } else {
+                    Ok(self)
+                }
+            }
+            (Some(k), Some(v)) => {
+                trace_field(Key::run_verifier(self.verifier, k), key_field_name, k)?;
+                let discriminant = Key::follow(self.verifier.buffer, k);
+                trace_field(
+                    verify_union(discriminant, self.verifier, v),
+                    val_field_name,
+                    v,
+                )?;
+                Ok(self)
+            }
+            _ => InvalidFlatbuffer::new_inconsistent_union(key_field_name, val_field_name),
+        }
+    }
+    pub fn finish(self) -> &'ver mut Verifier<'opts, 'buf> {
+        self.verifier.depth -= 1;
+        self.verifier
+    }
+}
+
+// Needs to be implemented for Tables and maybe structs.
+// Unions need some special treatment.
+pub trait Verifiable {
+    /// Runs the verifier for this type, assuming its at position `pos` in the verifier's buffer.
+    /// Should not need to be called directly.
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()>;
+}
+
+// Verify the uoffset and then pass verifier to the type being pointed to.
+impl<T: Verifiable> Verifiable for ForwardsUOffset<T> {
+    #[inline]
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()> {
+        let offset = v.get_uoffset(pos)? as usize;
+        let next_pos = offset.saturating_add(pos);
+        T::run_verifier(v, next_pos)
+    }
+}
+
+/// Checks and returns the range containing the flatbuffers vector.
+fn verify_vector_range<T>(v: &mut Verifier, pos: usize) -> Result<core::ops::Range<usize>> {
+    let len = v.get_uoffset(pos)? as usize;
+    let start = pos.saturating_add(SIZE_UOFFSET);
+    v.is_aligned::<T>(start)?;
+    let size = len.saturating_mul(core::mem::size_of::<T>());
+    let end = start.saturating_add(size);
+    v.range_in_buffer(start, size)?;
+    Ok(core::ops::Range { start, end })
+}
+
+pub trait SimpleToVerifyInSlice {}
+impl SimpleToVerifyInSlice for bool {}
+impl SimpleToVerifyInSlice for i8 {}
+impl SimpleToVerifyInSlice for u8 {}
+impl SimpleToVerifyInSlice for i16 {}
+impl SimpleToVerifyInSlice for u16 {}
+impl SimpleToVerifyInSlice for i32 {}
+impl SimpleToVerifyInSlice for u32 {}
+impl SimpleToVerifyInSlice for f32 {}
+impl SimpleToVerifyInSlice for i64 {}
+impl SimpleToVerifyInSlice for u64 {}
+impl SimpleToVerifyInSlice for f64 {}
+
+impl<T: SimpleToVerifyInSlice> Verifiable for Vector<'_, T> {
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()> {
+        verify_vector_range::<T>(v, pos)?;
+        Ok(())
+    }
+}
+
+impl<T: Verifiable> Verifiable for SkipSizePrefix<T> {
+    #[inline]
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()> {
+        T::run_verifier(v, pos.saturating_add(crate::SIZE_SIZEPREFIX))
+    }
+}
+
+impl<T: Verifiable> Verifiable for Vector<'_, ForwardsUOffset<T>> {
+    #[inline]
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()> {
+        let range = verify_vector_range::<ForwardsUOffset<T>>(v, pos)?;
+        let size = core::mem::size_of::<ForwardsUOffset<T>>();
+        for (i, element_pos) in range.step_by(size).enumerate() {
+            trace_elem(
+                <ForwardsUOffset<T>>::run_verifier(v, element_pos),
+                i,
+                element_pos,
+            )?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> Verifiable for &'a str {
+    #[inline]
+    fn run_verifier(v: &mut Verifier, pos: usize) -> Result<()> {
+        let range = verify_vector_range::<u8>(v, pos)?;
+        let has_null_terminator = v.buffer.get(range.end).map(|&b| b == 0).unwrap_or(false);
+        let s = core::str::from_utf8(&v.buffer[range.clone()]);
+        if let Err(error) = s {
+            return Err(InvalidFlatbuffer::Utf8Error {
+                error,
+                range,
+                error_trace: Default::default(),
+            });
+        }
+        if !v.opts.ignore_missing_null_terminator && !has_null_terminator {
+            return Err(InvalidFlatbuffer::MissingNullTerminator {
+                range,
+                error_trace: Default::default(),
+            });
+        }
+        Ok(())
+    }
+}
+
+// Verify VectorOfTables, Unions, Arrays, Structs...
+macro_rules! impl_verifiable_for {
+    ($T: ty) => {
+        impl Verifiable for $T {
+            #[inline]
+            fn run_verifier<'opts, 'buf>(v: &mut Verifier<'opts, 'buf>, pos: usize) -> Result<()> {
+                v.in_buffer::<$T>(pos)
+            }
+        }
+    };
+}
+impl_verifiable_for!(bool);
+impl_verifiable_for!(u8);
+impl_verifiable_for!(i8);
+impl_verifiable_for!(u16);
+impl_verifiable_for!(i16);
+impl_verifiable_for!(u32);
+impl_verifiable_for!(i32);
+impl_verifiable_for!(f32);
+impl_verifiable_for!(u64);
+impl_verifiable_for!(i64);
+impl_verifiable_for!(f64);
diff --git a/rust/flatbuffers/src/vtable.rs b/rust/flatbuffers/src/vtable.rs
index 98fb1e2..bbb7190 100644
--- a/rust/flatbuffers/src/vtable.rs
+++ b/rust/flatbuffers/src/vtable.rs
@@ -40,10 +40,10 @@
         (self.num_bytes() / SIZE_VOFFSET) - 2
     }
     pub fn num_bytes(&self) -> usize {
-        read_scalar_at::<VOffsetT>(self.buf, self.loc) as usize
+        unsafe { read_scalar_at::<VOffsetT>(self.buf, self.loc) as usize }
     }
     pub fn object_inline_num_bytes(&self) -> usize {
-        let n = read_scalar_at::<VOffsetT>(self.buf, self.loc + SIZE_VOFFSET);
+        let n = unsafe { read_scalar_at::<VOffsetT>(self.buf, self.loc + SIZE_VOFFSET) };
         n as usize
     }
     pub fn get_field(&self, idx: usize) -> VOffsetT {
@@ -51,17 +51,19 @@
         if idx > self.num_fields() {
             return 0;
         }
-        read_scalar_at::<VOffsetT>(
-            self.buf,
-            self.loc + SIZE_VOFFSET + SIZE_VOFFSET + SIZE_VOFFSET * idx,
-        )
+        unsafe {
+            read_scalar_at::<VOffsetT>(
+                self.buf,
+                self.loc + SIZE_VOFFSET + SIZE_VOFFSET + SIZE_VOFFSET * idx,
+            )
+        }
     }
     pub fn get(&self, byte_loc: VOffsetT) -> VOffsetT {
         // TODO(rw): distinguish between None and 0?
         if byte_loc as usize >= self.num_bytes() {
             return 0;
         }
-        read_scalar_at::<VOffsetT>(self.buf, self.loc + byte_loc as usize)
+        unsafe { read_scalar_at::<VOffsetT>(self.buf, self.loc + byte_loc as usize) }
     }
     pub fn as_bytes(&self) -> &[u8] {
         let len = self.num_bytes();
diff --git a/rust/flatbuffers/src/vtable_writer.rs b/rust/flatbuffers/src/vtable_writer.rs
index 57380bd..9b61dac 100644
--- a/rust/flatbuffers/src/vtable_writer.rs
+++ b/rust/flatbuffers/src/vtable_writer.rs
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-use std::ptr::write_bytes;
+use core::ptr::write_bytes;
 
-use crate::endian_scalar::{emplace_scalar, read_scalar_at};
+use crate::endian_scalar::emplace_scalar;
 use crate::primitives::*;
 
 /// VTableWriter compartmentalizes actions needed to create a vtable.
@@ -40,24 +40,18 @@
     /// to the provided value.
     #[inline(always)]
     pub fn write_vtable_byte_length(&mut self, n: VOffsetT) {
-        emplace_scalar::<VOffsetT>(&mut self.buf[..SIZE_VOFFSET], n);
+        unsafe {
+            emplace_scalar::<VOffsetT>(&mut self.buf[..SIZE_VOFFSET], n);
+        }
         debug_assert_eq!(n as usize, self.buf.len());
     }
 
     /// Writes an object length (in bytes) into the vtable.
     #[inline(always)]
     pub fn write_object_inline_size(&mut self, n: VOffsetT) {
-        emplace_scalar::<VOffsetT>(&mut self.buf[SIZE_VOFFSET..2 * SIZE_VOFFSET], n);
-    }
-
-    /// Gets an object field offset from the vtable. Only used for debugging.
-    ///
-    /// Note that this expects field offsets (which are like pointers), not
-    /// field ids (which are like array indices).
-    #[inline(always)]
-    pub fn get_field_offset(&self, vtable_offset: VOffsetT) -> VOffsetT {
-        let idx = vtable_offset as usize;
-        read_scalar_at::<VOffsetT>(&self.buf, idx)
+        unsafe {
+            emplace_scalar::<VOffsetT>(&mut self.buf[SIZE_VOFFSET..2 * SIZE_VOFFSET], n);
+        }
     }
 
     /// Writes an object field offset into the vtable.
@@ -67,7 +61,9 @@
     #[inline(always)]
     pub fn write_field_offset(&mut self, vtable_offset: VOffsetT, object_data_offset: VOffsetT) {
         let idx = vtable_offset as usize;
-        emplace_scalar::<VOffsetT>(&mut self.buf[idx..idx + SIZE_VOFFSET], object_data_offset);
+        unsafe {
+            emplace_scalar::<VOffsetT>(&mut self.buf[idx..idx + SIZE_VOFFSET], object_data_offset);
+        }
     }
 
     /// Clears all data in this VTableWriter. Used to cleanly undo a