diff --git a/vortex-file/public-api.lock b/vortex-file/public-api.lock
index bb2a9b00d81..04db1feb837 100644
--- a/vortex-file/public-api.lock
+++ b/vortex-file/public-api.lock
@@ -184,6 +184,10 @@ pub fn vortex_file::Footer::into_serializer(self) -> vortex_file::FooterSerializ
 
 pub fn vortex_file::Footer::layout(&self) -> &vortex_layout::layout::LayoutRef
 
+pub fn vortex_file::Footer::metadata_segment(&self, &str) -> core::option::Option<&vortex_buffer::ByteBuffer>
+
+pub fn vortex_file::Footer::metadata_segments(&self) -> impl core::iter::traits::iterator::Iterator<Item = (&str, &vortex_buffer::ByteBuffer)>
+
 pub fn vortex_file::Footer::row_count(&self) -> u64
 
 pub fn vortex_file::Footer::segment_map(&self) -> &alloc::sync::Arc<[vortex_file::SegmentSpec]>
@@ -206,10 +210,14 @@ pub fn vortex_file::FooterDeserializer::buffer(&self) -> &vortex_buffer::ByteBuf
 
 pub fn vortex_file::FooterDeserializer::deserialize(&mut self) -> vortex_error::VortexResult<vortex_file::DeserializeStep>
 
+pub fn vortex_file::FooterDeserializer::include_metadata(self) -> Self
+
 pub fn vortex_file::FooterDeserializer::prefix_data(&mut self, vortex_buffer::ByteBuffer)
 
 pub fn vortex_file::FooterDeserializer::with_dtype(self, vortex_array::dtype::DType) -> Self
 
+pub fn vortex_file::FooterDeserializer::with_include_metadata(self, bool) -> Self
+
 pub fn vortex_file::FooterDeserializer::with_size(self, u64) -> Self
 
 pub fn vortex_file::FooterDeserializer::with_some_dtype(self, core::option::Option<vortex_array::dtype::DType>) -> Self
@@ -276,6 +284,10 @@ pub fn vortex_file::VortexFile::footer(&self) -> &vortex_file::Footer
 
 pub fn vortex_file::VortexFile::layout_reader(&self) -> vortex_error::VortexResult<alloc::sync::Arc<dyn vortex_layout::reader::LayoutReader>>
 
+pub fn vortex_file::VortexFile::metadata_segment(&self, &str) -> core::option::Option<&vortex_buffer::ByteBuffer>
+
+pub fn vortex_file::VortexFile::metadata_segments(&self) -> impl core::iter::traits::iterator::Iterator<Item = (&str, &vortex_buffer::ByteBuffer)>
+
 pub fn vortex_file::VortexFile::row_count(&self) -> u64
 
 pub fn vortex_file::VortexFile::scan(&self) -> vortex_error::VortexResult<vortex_layout::scan::scan_builder::ScanBuilder<vortex_array::array::erased::ArrayRef>>
@@ -292,6 +304,8 @@ pub struct vortex_file::VortexOpenOptions
 
 impl vortex_file::VortexOpenOptions
 
+pub fn vortex_file::VortexOpenOptions::include_metadata(self) -> Self
+
 pub async fn vortex_file::VortexOpenOptions::open(self, alloc::sync::Arc<dyn vortex_io::read_at::VortexReadAt>) -> vortex_error::VortexResult<vortex_file::VortexFile>
 
 pub fn vortex_file::VortexOpenOptions::open_buffer<B: core::convert::Into<vortex_buffer::ByteBuffer>>(self, B) -> vortex_error::VortexResult<vortex_file::VortexFile>
@@ -306,6 +320,8 @@ pub fn vortex_file::VortexOpenOptions::with_file_size(self, u64) -> Self
 
 pub fn vortex_file::VortexOpenOptions::with_footer(self, vortex_file::Footer) -> Self
 
+pub fn vortex_file::VortexOpenOptions::with_include_metadata(self, bool) -> Self
+
 pub fn vortex_file::VortexOpenOptions::with_initial_read_size(self, usize) -> Self
 
 pub fn vortex_file::VortexOpenOptions::with_labels(self, alloc::vec::Vec<vortex_metrics::Label>) -> Self
@@ -338,6 +354,10 @@ pub fn vortex_file::VortexWriteOptions::new(vortex_session::VortexSession) -> Se
 
 pub fn vortex_file::VortexWriteOptions::with_file_statistics(self, alloc::vec::Vec<vortex_array::expr::stats::Stat>) -> Self
 
+pub fn vortex_file::VortexWriteOptions::with_metadata_segment(self, impl core::convert::Into<alloc::string::String>, impl core::convert::Into<vortex_buffer::ByteBuffer>) -> Self
+
+pub fn vortex_file::VortexWriteOptions::with_metadata_segments<I, K, B>(self, I) -> Self where I: core::iter::traits::collect::IntoIterator<Item = (K, B)>, K: core::convert::Into<alloc::string::String>, B: core::convert::Into<vortex_buffer::ByteBuffer>
+
 pub fn vortex_file::VortexWriteOptions::with_strategy(self, alloc::sync::Arc<dyn vortex_layout::strategy::LayoutStrategy>) -> Self
 
 pub struct vortex_file::WriteStrategyBuilder
diff --git a/vortex-file/src/file.rs b/vortex-file/src/file.rs
index f321d774197..a588d5648f4 100644
--- a/vortex-file/src/file.rs
+++ b/vortex-file/src/file.rs
@@ -23,6 +23,7 @@ use vortex_array::dtype::FieldPathSet;
 use vortex_array::expr::Expression;
 use vortex_array::expr::pruning::checked_pruning_expr;
 use vortex_array::scalar_fn::internal::row_count::substitute_row_count;
+use vortex_buffer::ByteBuffer;
 use vortex_error::VortexResult;
 use vortex_layout::LayoutReader;
 use vortex_layout::scan::layout::LayoutReaderDataSource;
@@ -76,6 +77,16 @@ impl VortexFile {
         self.footer.statistics()
     }
 
+    /// Returns the user-defined metadata segments loaded for this file.
+    pub fn metadata_segments(&self) -> impl Iterator<Item = (&str, &ByteBuffer)> {
+        self.footer.metadata_segments()
+    }
+
+    /// Returns the loaded user-defined metadata segment for the given key.
+    pub fn metadata_segment(&self, key: &str) -> Option<&ByteBuffer> {
+        self.footer.metadata_segment(key)
+    }
+
     /// Create a new segment source for reading from the file.
     ///
     /// This may spawn a background I/O driver that will exit when the returned segment source
diff --git a/vortex-file/src/footer/deserializer.rs b/vortex-file/src/footer/deserializer.rs
index 769b94c715b..1ca141635a1 100644
--- a/vortex-file/src/footer/deserializer.rs
+++ b/vortex-file/src/footer/deserializer.rs
@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::sync::Arc;
+
 use flatbuffers::root;
 use vortex_array::dtype::DType;
 use vortex_buffer::ByteBuffer;
@@ -12,6 +14,7 @@ use vortex_error::vortex_err;
 use vortex_flatbuffers::FlatBuffer;
 use vortex_flatbuffers::ReadFlatBuffer;
 use vortex_session::VortexSession;
+use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::EOF_SIZE;
 use crate::Footer;
@@ -19,6 +22,7 @@ use crate::MAGIC_BYTES;
 use crate::VERSION;
 use crate::footer::FileStatistics;
 use crate::footer::postscript::Postscript;
+use crate::footer::postscript::PostscriptMetadata;
 use crate::footer::postscript::PostscriptSegment;
 
 /// Deserialize a footer from the end of a Vortex file or created from a
@@ -37,6 +41,8 @@ pub struct FooterDeserializer {
 
     // The file size, possibly provided externally.
     file_size: Option<u64>,
+    // Whether to include user-defined metadata segments in the footer read.
+    include_metadata: bool,
     // The postscript, once we've parsed it.
     postscript: Option<Postscript>,
 }
@@ -48,6 +54,7 @@ impl FooterDeserializer {
             session,
             dtype: None,
             file_size: None,
+            include_metadata: false,
             postscript: None,
         }
     }
@@ -72,6 +79,18 @@ impl FooterDeserializer {
         self
     }
 
+    /// Include user-defined metadata segments in footer deserialization.
+    pub fn include_metadata(mut self) -> Self {
+        self.include_metadata = true;
+        self
+    }
+
+    /// Whether to include user-defined metadata segments in footer deserialization.
+    pub fn with_include_metadata(mut self, include_metadata: bool) -> Self {
+        self.include_metadata = include_metadata;
+        self
+    }
+
     /// Prefix more data to the existing buffer when requested by the deserializer.
     pub fn prefix_data(&mut self, more_data: ByteBuffer) {
         let mut buffer = ByteBufferMut::with_capacity(self.buffer.len() + more_data.len());
@@ -119,6 +138,11 @@ impl FooterDeserializer {
         if let Some(stats_segment) = &postscript.statistics {
             read_more_offset = read_more_offset.min(stats_segment.offset);
         }
+        if self.include_metadata {
+            for metadata in &postscript.metadata {
+                read_more_offset = read_more_offset.min(metadata.segment.offset);
+            }
+        }
         read_more_offset = read_more_offset.min(postscript.layout.offset);
         read_more_offset = read_more_offset.min(postscript.footer.offset);
 
@@ -151,14 +175,27 @@ impl FooterDeserializer {
                 )
             })
             .transpose()?;
+        let metadata = if self.include_metadata {
+            Arc::new(
+                postscript
+                    .metadata
+                    .iter()
+                    .map(|metadata| {
+                        self.parse_metadata_segment(initial_offset, &self.buffer, metadata)
+                    })
+                    .collect::<VortexResult<HashMap<_, _>>>()?,
+            )
+        } else {
+            Arc::new(HashMap::default())
+        };
 
         Ok(DeserializeStep::Done(self.parse_footer(
             initial_offset,
             &self.buffer,
-            &postscript.footer,
-            &postscript.layout,
+            postscript,
             dtype,
             file_stats,
+            metadata,
         )?))
     }
 
@@ -238,27 +275,67 @@ impl FooterDeserializer {
         FileStatistics::from_flatbuffer(&fb, dtype, session)
     }
 
+    /// Parse a user-defined metadata segment from the initial read buffer.
+    fn parse_metadata_segment(
+        &self,
+        initial_offset: u64,
+        initial_read: &ByteBuffer,
+        metadata: &PostscriptMetadata,
+    ) -> VortexResult<(String, ByteBuffer)> {
+        let offset = usize::try_from(metadata.segment.offset - initial_offset)?;
+        let length = metadata.segment.length as usize;
+        let end = offset
+            .checked_add(length)
+            .ok_or_else(|| vortex_err!("Metadata segment range overflowed usize"))?;
+
+        if end > initial_read.len() {
+            vortex_bail!(
+                "Metadata segment {} range {}..{} out of bounds for initial read of length {}",
+                metadata.key,
+                offset,
+                end,
+                initial_read.len()
+            );
+        }
+
+        Ok((
+            metadata.key.clone(),
+            initial_read
+                .slice_unaligned(offset..end)
+                .aligned(metadata.segment.alignment),
+        ))
+    }
+
     /// Parse the rest of the footer from the initial read.
     fn parse_footer(
         &self,
         initial_offset: u64,
         initial_read: &[u8],
-        footer_segment: &PostscriptSegment,
-        layout_segment: &PostscriptSegment,
+        postscript: &Postscript,
         dtype: DType,
         file_stats: Option<FileStatistics>,
+        metadata: Arc<HashMap<String, ByteBuffer>>,
     ) -> VortexResult<Footer> {
+        let footer_segment = &postscript.footer;
         let footer_offset = usize::try_from(footer_segment.offset - initial_offset)?;
         let footer_bytes = FlatBuffer::copy_from(
             &initial_read[footer_offset..footer_offset + (footer_segment.length as usize)],
         );
 
+        let layout_segment = &postscript.layout;
         let layout_offset = usize::try_from(layout_segment.offset - initial_offset)?;
         let layout_bytes = FlatBuffer::copy_from(
             &initial_read[layout_offset..layout_offset + (layout_segment.length as usize)],
         );
 
-        Footer::from_flatbuffer(footer_bytes, layout_bytes, dtype, file_stats, &self.session)
+        Footer::from_flatbuffer(
+            footer_bytes,
+            layout_bytes,
+            dtype,
+            file_stats,
+            metadata,
+            &self.session,
+        )
     }
 }
 
diff --git a/vortex-file/src/footer/mod.rs b/vortex-file/src/footer/mod.rs
index ac2153f7cd1..29eaac9fea1 100644
--- a/vortex-file/src/footer/mod.rs
+++ b/vortex-file/src/footer/mod.rs
@@ -38,6 +38,21 @@ use vortex_layout::layout_from_flatbuffer_with_options;
 use vortex_layout::session::LayoutSessionExt;
 use vortex_session::VortexSession;
 use vortex_session::registry::ReadContext;
+use vortex_utils::aliases::hash_map::HashMap;
+
+/// Maximum number of user-defined metadata segments stored in the postscript.
+///
+/// The postscript has a fixed 64 KiB budget and must remain small enough for readers to discover
+/// the footer and required segment locations from the initial read. Sixteen entries keeps metadata
+/// bookkeeping well under 2 KiB for typical key lengths while leaving almost all of the postscript
+/// budget available for the required file segments.
+pub(crate) const MAX_METADATA_SEGMENTS: usize = 16;
+
+/// Maximum length, in UTF-8 bytes, of a user-defined metadata key.
+///
+/// Metadata keys are stored directly in the fixed-size postscript. Keeping keys short prevents
+/// user-defined labels from consuming a disproportionate share of the postscript budget.
+pub(crate) const MAX_METADATA_KEY_BYTES: usize = 32;
 
 /// Captures the layout information of a Vortex file.
 #[derive(Debug, Clone)]
@@ -45,6 +60,7 @@ pub struct Footer {
     root_layout: LayoutRef,
     segments: Arc<[SegmentSpec]>,
     statistics: Option<FileStatistics>,
+    metadata: Arc<HashMap<String, ByteBuffer>>,
     // The specific arrays used within the file, in the order they were registered.
     array_read_ctx: ReadContext,
     // The approximate size of the footer in bytes, used for caching and memory management.
@@ -56,12 +72,14 @@ impl Footer {
         root_layout: LayoutRef,
         segments: Arc<[SegmentSpec]>,
         statistics: Option<FileStatistics>,
+        metadata: Arc<HashMap<String, ByteBuffer>>,
         array_read_ctx: ReadContext,
     ) -> Self {
         Self {
             root_layout,
             segments,
             statistics,
+            metadata,
             array_read_ctx,
             approx_byte_size: None,
         }
@@ -78,6 +96,7 @@ impl Footer {
         layout_bytes: FlatBuffer,
         dtype: DType,
         statistics: Option<FileStatistics>,
+        metadata: Arc<HashMap<String, ByteBuffer>>,
         session: &VortexSession,
     ) -> VortexResult<Self> {
         let approx_byte_size = footer_bytes.len() + layout_bytes.len();
@@ -126,6 +145,7 @@ impl Footer {
             root_layout,
             segments,
             statistics,
+            metadata,
             array_read_ctx,
             approx_byte_size: Some(approx_byte_size),
         })
@@ -146,6 +166,18 @@ impl Footer {
         self.statistics.as_ref()
     }
 
+    /// Returns the user-defined metadata segments loaded for this file.
+    pub fn metadata_segments(&self) -> impl Iterator<Item = (&str, &ByteBuffer)> {
+        self.metadata
+            .iter()
+            .map(|(key, metadata)| (key.as_str(), metadata))
+    }
+
+    /// Returns the loaded user-defined metadata segment for the given key.
+    pub fn metadata_segment(&self, key: &str) -> Option<&ByteBuffer> {
+        self.metadata.get(key)
+    }
+
     /// Returns the [`DType`] of the file.
     pub fn dtype(&self) -> &DType {
         self.root_layout.dtype()
diff --git a/vortex-file/src/footer/postscript.rs b/vortex-file/src/footer/postscript.rs
index 105a25cf287..c29279ca6e0 100644
--- a/vortex-file/src/footer/postscript.rs
+++ b/vortex-file/src/footer/postscript.rs
@@ -12,6 +12,10 @@ use vortex_flatbuffers::FlatBufferRoot;
 use vortex_flatbuffers::ReadFlatBuffer;
 use vortex_flatbuffers::WriteFlatBuffer;
 use vortex_flatbuffers::footer as fb;
+use vortex_utils::aliases::hash_set::HashSet;
+
+use super::MAX_METADATA_KEY_BYTES;
+use super::MAX_METADATA_SEGMENTS;
 
 /// The postscript captures the locations and compression for the initial segments required for
 /// reading a Vortex file.
@@ -20,6 +24,7 @@ pub(crate) struct Postscript {
     pub(crate) layout: PostscriptSegment,
     pub(crate) statistics: Option<PostscriptSegment>,
     pub(crate) footer: PostscriptSegment,
+    pub(crate) metadata: Vec<PostscriptMetadata>,
 }
 
 impl FlatBufferRoot for Postscript {}
@@ -43,6 +48,15 @@ impl WriteFlatBuffer for Postscript {
             .map(|ps| ps.write_flatbuffer(fbb))
             .transpose()?;
         let footer = self.footer.write_flatbuffer(fbb)?;
+        let metadata = if self.metadata.is_empty() {
+            None
+        } else {
+            let mut metadata = Vec::with_capacity(self.metadata.len());
+            for entry in &self.metadata {
+                metadata.push(entry.write_flatbuffer(fbb)?);
+            }
+            Some(fbb.create_vector(metadata.as_slice()))
+        };
         Ok(fb::Postscript::create(
             fbb,
             &fb::PostscriptArgs {
@@ -50,6 +64,7 @@ impl WriteFlatBuffer for Postscript {
                 layout: Some(layout),
                 statistics,
                 footer: Some(footer),
+                metadata,
             },
         ))
     }
@@ -62,6 +77,19 @@ impl ReadFlatBuffer for Postscript {
     fn read_flatbuffer<'buf>(
         fb: &<Self::Source<'buf> as Follow<'buf>>::Inner,
     ) -> Result<Self, Self::Error> {
+        let metadata = fb
+            .metadata()
+            .map(|metadata| {
+                metadata
+                    .iter()
+                    .map(|entry| PostscriptMetadata::read_flatbuffer(&entry))
+                    .collect::<Result<Vec<_>, _>>()
+            })
+            .transpose()?
+            .unwrap_or_default();
+
+        validate_metadata_entries(&metadata)?;
+
         Ok(Self {
             dtype: fb
                 .dtype()
@@ -79,6 +107,94 @@ impl ReadFlatBuffer for Postscript {
                 &fb.footer()
                     .ok_or_else(|| vortex_err!("Postscript missing footer segment"))?,
             )?,
+            metadata,
+        })
+    }
+}
+
+fn validate_metadata_entries(metadata: &[PostscriptMetadata]) -> VortexResult<()> {
+    if metadata.len() > MAX_METADATA_SEGMENTS {
+        return Err(vortex_err!(
+            "Postscript contains {} metadata segments, but Vortex supports at most {} metadata segments and at most {} bytes per metadata key",
+            metadata.len(),
+            MAX_METADATA_SEGMENTS,
+            MAX_METADATA_KEY_BYTES
+        ));
+    }
+
+    let mut seen_keys = HashSet::with_capacity(metadata.len());
+    for entry in metadata {
+        validate_metadata_key(&entry.key)?;
+        if !seen_keys.insert(&entry.key) {
+            return Err(vortex_err!(
+                "Postscript contains duplicate metadata key {}",
+                entry.key
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+fn validate_metadata_key(key: &str) -> VortexResult<()> {
+    if key.is_empty() {
+        return Err(vortex_err!(
+            "Postscript metadata key must not be empty; Vortex supports at most {} metadata segments and metadata keys must be at most {} bytes",
+            MAX_METADATA_SEGMENTS,
+            MAX_METADATA_KEY_BYTES
+        ));
+    }
+
+    let key_bytes = key.len();
+    if key_bytes > MAX_METADATA_KEY_BYTES {
+        return Err(vortex_err!(
+            "Postscript metadata key {key:?} is {key_bytes} bytes, but Vortex supports at most {} metadata segments and metadata keys must be at most {} bytes",
+            MAX_METADATA_SEGMENTS,
+            MAX_METADATA_KEY_BYTES
+        ));
+    }
+
+    Ok(())
+}
+
+pub(crate) struct PostscriptMetadata {
+    pub(crate) key: String,
+    pub(crate) segment: PostscriptSegment,
+}
+
+impl FlatBufferRoot for PostscriptMetadata {}
+
+impl WriteFlatBuffer for PostscriptMetadata {
+    type Target<'a> = fb::PostscriptMetadata<'a>;
+
+    fn write_flatbuffer<'fb>(
+        &self,
+        fbb: &mut FlatBufferBuilder<'fb>,
+    ) -> VortexResult<WIPOffset<Self::Target<'fb>>> {
+        let key = fbb.create_string(&self.key);
+        let segment = self.segment.write_flatbuffer(fbb)?;
+        Ok(fb::PostscriptMetadata::create(
+            fbb,
+            &fb::PostscriptMetadataArgs {
+                key: Some(key),
+                segment: Some(segment),
+            },
+        ))
+    }
+}
+
+impl ReadFlatBuffer for PostscriptMetadata {
+    type Source<'a> = fb::PostscriptMetadata<'a>;
+    type Error = VortexError;
+
+    fn read_flatbuffer<'buf>(
+        fb: &<Self::Source<'buf> as Follow<'buf>>::Inner,
+    ) -> Result<Self, Self::Error> {
+        // The FlatBuffers verifier enforces that `key` and `segment` are present before this
+        // accessor can panic on a malformed required field.
+        Ok(Self {
+            key: fb.key().to_string(),
+            segment: PostscriptSegment::read_flatbuffer(&fb.segment())?,
         })
     }
 }
@@ -125,3 +241,102 @@ impl ReadFlatBuffer for PostscriptSegment {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use vortex_flatbuffers::ReadFlatBuffer;
+    use vortex_flatbuffers::WriteFlatBufferExt;
+
+    use super::*;
+
+    fn segment(offset: u64) -> PostscriptSegment {
+        PostscriptSegment {
+            offset,
+            length: 1,
+            alignment: Alignment::none(),
+        }
+    }
+
+    fn read_postscript_error(postscript: &Postscript) -> String {
+        let bytes = postscript.write_flatbuffer_bytes().unwrap();
+        match Postscript::read_flatbuffer_bytes(&bytes) {
+            Ok(_) => panic!("expected postscript read to fail"),
+            Err(err) => err.to_string(),
+        }
+    }
+
+    #[test]
+    fn duplicate_metadata_keys_are_rejected() {
+        let err = read_postscript_error(&Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![
+                PostscriptMetadata {
+                    key: "metadata".to_string(),
+                    segment: segment(2),
+                },
+                PostscriptMetadata {
+                    key: "metadata".to_string(),
+                    segment: segment(3),
+                },
+            ],
+        });
+
+        assert!(err.contains("duplicate metadata key"));
+    }
+
+    #[test]
+    fn empty_metadata_keys_are_rejected() {
+        let err = read_postscript_error(&Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![PostscriptMetadata {
+                key: String::new(),
+                segment: segment(2),
+            }],
+        });
+
+        assert!(err.contains("metadata key must not be empty"));
+    }
+
+    #[test]
+    fn long_metadata_keys_are_rejected() {
+        let err = read_postscript_error(&Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: vec![PostscriptMetadata {
+                key: "é".repeat((MAX_METADATA_KEY_BYTES / "é".len()) + 1),
+                segment: segment(2),
+            }],
+        });
+
+        assert!(err.contains("34 bytes"));
+        assert!(err.contains("at most 32 bytes"));
+        assert!(err.contains("at most 16 metadata segments"));
+    }
+
+    #[test]
+    fn too_many_metadata_segments_are_rejected() {
+        let err = read_postscript_error(&Postscript {
+            dtype: None,
+            layout: segment(0),
+            statistics: None,
+            footer: segment(1),
+            metadata: (0..=MAX_METADATA_SEGMENTS)
+                .map(|idx| PostscriptMetadata {
+                    key: format!("metadata-{idx}"),
+                    segment: segment(2 + idx as u64),
+                })
+                .collect(),
+        });
+
+        assert!(err.contains("at most 16 metadata segments"));
+        assert!(err.contains("at most 32 bytes"));
+    }
+}
diff --git a/vortex-file/src/footer/serializer.rs b/vortex-file/src/footer/serializer.rs
index af5a7f9e909..ec168f70aec 100644
--- a/vortex-file/src/footer/serializer.rs
+++ b/vortex-file/src/footer/serializer.rs
@@ -21,6 +21,7 @@ use crate::MAX_POSTSCRIPT_SIZE;
 use crate::VERSION;
 use crate::footer::file_layout::FooterFlatBufferWriter;
 use crate::footer::postscript::Postscript;
+use crate::footer::postscript::PostscriptMetadata;
 use crate::footer::postscript::PostscriptSegment;
 
 pub struct FooterSerializer {
@@ -66,6 +67,19 @@ impl FooterSerializer {
     pub fn serialize(mut self) -> VortexResult<Vec<ByteBuffer>> {
         let mut buffers = vec![];
 
+        let mut metadata = self.footer.metadata_segments().collect::<Vec<_>>();
+        metadata.sort_unstable_by_key(|(key, _)| *key);
+
+        let mut metadata_segments = Vec::with_capacity(metadata.len());
+        for (key, metadata) in metadata {
+            let (metadata_buffers, segment) = write_buffer(&mut self.offset, metadata.clone())?;
+            buffers.extend(metadata_buffers);
+            metadata_segments.push(PostscriptMetadata {
+                key: key.to_string(),
+                segment,
+            });
+        }
+
         let dtype_segment = if self.exclude_dtype {
             None
         } else {
@@ -110,6 +124,7 @@ impl FooterSerializer {
             layout: layout_segment,
             statistics: statistics_segment,
             footer: footer_segment,
+            metadata: metadata_segments,
         };
         let postscript_buffer = postscript.write_flatbuffer_bytes()?;
         if postscript_buffer.len() > MAX_POSTSCRIPT_SIZE as usize {
@@ -153,3 +168,31 @@ fn write_flatbuffer<F: FlatBufferRoot + WriteFlatBuffer>(
 
     Ok((buffer.into_inner(), segment))
 }
+
+fn write_buffer(
+    offset: &mut u64,
+    buffer: ByteBuffer,
+) -> VortexResult<(Vec<ByteBuffer>, PostscriptSegment)> {
+    let length = u32::try_from(buffer.len())
+        .map_err(|_| vortex_err!("metadata segment length exceeds maximum u32"))?;
+    let alignment = buffer.alignment();
+
+    let padding = offset.next_multiple_of(*alignment as u64) - *offset;
+    let segment_offset = *offset + padding;
+
+    let segment = PostscriptSegment {
+        offset: segment_offset,
+        length,
+        alignment,
+    };
+
+    *offset += padding + u64::from(length);
+
+    let mut buffers = Vec::with_capacity(if padding == 0 { 1 } else { 2 });
+    if padding > 0 {
+        buffers.push(ByteBuffer::zeroed(padding as usize));
+    }
+    buffers.push(buffer);
+
+    Ok((buffers, segment))
+}
diff --git a/vortex-file/src/lib.rs b/vortex-file/src/lib.rs
index ce6598173a6..b5af3aaca76 100644
--- a/vortex-file/src/lib.rs
+++ b/vortex-file/src/lib.rs
@@ -45,9 +45,10 @@
 //!    1. An optional Schema, which if present is a valid flatbuffer representing a message::Schema
 //!    2. The Layout, which is a valid footer::Layout flatbuffer, and describes the physical byte ranges & relationships amongst
 //!       the those byte ranges that we wrote in part 1.
-//!    3. The Postscript, which is a valid footer::Postscript flatbuffer, containing the absolute start offsets of the Schema & Layout
-//!       flatbuffers within the file.
-//!    4. The End-of-File marker, which is 8 bytes, and contains the u16 version, u16 postscript length, and 4 magic bytes.
+//!    3. Optional user-defined metadata segments, keyed by strings in the Postscript.
+//!    4. The Postscript, which is a valid footer::Postscript flatbuffer, containing the absolute start offsets of the Schema,
+//!       Layout, Footer, Statistics, and user-defined metadata segments within the file.
+//!    5. The End-of-File marker, which is 8 bytes, and contains the u16 version, u16 postscript length, and 4 magic bytes.
 //!
 //! ## Illustrated File Format
 //! ```text
@@ -62,6 +63,10 @@
 //! │                            │
 //! ├────────────────────────────┤
 //! │                            │
+//! │  User Metadata Segments    │
+//! │                            │
+//! ├────────────────────────────┤
+//! │                            │
 //! │     Schema Flatbuffer      │
 //! │                            │
 //! ├────────────────────────────┤
@@ -70,8 +75,16 @@
 //! │                            │
 //! ├────────────────────────────┤
 //! │                            │
+//! │ File Statistics Flatbuffer │
+//! │                            │
+//! ├────────────────────────────┤
+//! │                            │
+//! │     Footer Flatbuffer      │
+//! │                            │
+//! ├────────────────────────────┤
+//! │                            │
 //! │    Postscript Flatbuffer   │
-//! │  (Schema & Layout Offsets) │
+//! │  (Footer Segment Offsets)  │
 //! │                            │
 //! ├────────────────────────────┤
 //! │     8-byte End of File     │
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 3a5d3cf90e5..e361ba2f135 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -54,6 +54,8 @@ pub struct VortexOpenOptions {
     dtype: Option<DType>,
     /// An optional, externally provided, file layout.
     footer: Option<Footer>,
+    /// Whether to include user-defined metadata segments when opening the file.
+    include_metadata: bool,
     /// The segments read during the initial read.
     initial_read_segments: RwLock<HashMap<SegmentId, ByteBuffer>>,
     /// A metrics registry for the file.
@@ -74,6 +76,7 @@ pub trait OpenOptionsSessionExt:
             file_size: None,
             dtype: None,
             footer: None,
+            include_metadata: false,
             initial_read_segments: Default::default(),
             metrics_registry: None,
             labels: Vec::default(),
@@ -136,6 +139,21 @@ impl VortexOpenOptions {
         self
     }
 
+    /// Include user-defined metadata segments when opening the file.
+    ///
+    /// By default, opening a file reads only the metadata required to interpret the layout.
+    /// Enabling this option includes all postscript metadata segments in the footer read.
+    pub fn include_metadata(mut self) -> Self {
+        self.include_metadata = true;
+        self
+    }
+
+    /// Configure whether user-defined metadata segments are included when opening the file.
+    pub fn with_include_metadata(mut self, include_metadata: bool) -> Self {
+        self.include_metadata = include_metadata;
+        self
+    }
+
     /// Configure a custom [`MetricsRegistry`] implementation.
     pub fn with_metrics_registry(mut self, metrics: Arc<dyn MetricsRegistry>) -> Self {
         self.metrics_registry = Some(metrics);
@@ -274,7 +292,8 @@ impl VortexOpenOptions {
 
         let mut deserializer = Footer::deserializer(initial_read, self.session.clone())
             .with_size(file_size)
-            .with_some_dtype(self.dtype.clone());
+            .with_some_dtype(self.dtype.clone())
+            .with_include_metadata(self.include_metadata);
 
         let footer = loop {
             match deserializer.deserialize()? {
diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs
index 2ba10d96684..5fade0ce0d0 100644
--- a/vortex-file/src/tests.rs
+++ b/vortex-file/src/tests.rs
@@ -59,8 +59,10 @@ use vortex_array::stream::ArrayStreamAdapter;
 use vortex_array::stream::ArrayStreamExt;
 use vortex_array::validity::Validity;
 use vortex_buffer::Buffer;
+use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
 use vortex_buffer::buffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::Layout;
@@ -68,6 +70,8 @@ use vortex_layout::scan::scan_builder::ScanBuilder;
 use vortex_layout::session::LayoutSession;
 use vortex_session::VortexSession;
 
+use crate::DeserializeStep;
+use crate::MAX_POSTSCRIPT_SIZE;
 use crate::OpenOptionsSessionExt;
 use crate::V1_FOOTER_FBS_SIZE;
 use crate::VERSION;
@@ -1680,6 +1684,140 @@ async fn test_writer_with_statistics() -> VortexResult<()> {
     Ok(())
 }
 
+async fn metadata_write_error<I>(metadata: I) -> VortexResult<String>
+where
+    I: IntoIterator<Item = (String, ByteBuffer)>,
+{
+    let array =
+        StructArray::from_fields(&[("numbers", buffer![1u32, 2, 3].into_array())])?.into_array();
+    let mut buf = ByteBufferMut::empty();
+
+    match SESSION
+        .write_options()
+        .with_metadata_segments(metadata)
+        .write(&mut buf, array.to_array_stream())
+        .await
+    {
+        Ok(_) => panic!("expected metadata write to fail"),
+        Err(err) => Ok(err.to_string()),
+    }
+}
+
+#[tokio::test]
+async fn test_file_metadata_segments_roundtrip() -> VortexResult<()> {
+    let array =
+        StructArray::from_fields(&[("numbers", buffer![1u32, 2, 3].into_array())])?.into_array();
+    let small = ByteBuffer::copy_from(b"{\"source\":\"test\"}");
+    let large = ByteBuffer::copy_from(vec![7u8; usize::from(MAX_POSTSCRIPT_SIZE) + 1024]);
+
+    let mut buf = ByteBufferMut::empty();
+    let summary = SESSION
+        .write_options()
+        .with_metadata_segment("application/json", ByteBuffer::copy_from(b"old"))
+        .with_metadata_segment("application/json", small.clone())
+        .with_metadata_segment("large", large.clone())
+        .write(&mut buf, array.to_array_stream())
+        .await?;
+
+    assert_eq!(summary.footer().metadata_segments().count(), 2);
+    assert_eq!(
+        summary
+            .footer()
+            .metadata_segment("application/json")
+            .map(ByteBuffer::as_slice),
+        Some(small.as_slice())
+    );
+
+    let bytes = ByteBuffer::from(buf);
+    let file_without_metadata = SESSION.open_options().open_buffer(bytes.clone())?;
+    assert_eq!(file_without_metadata.metadata_segments().count(), 0);
+    assert!(
+        file_without_metadata
+            .metadata_segment("application/json")
+            .is_none()
+    );
+
+    let file = SESSION
+        .open_options()
+        .include_metadata()
+        .open_buffer(bytes.clone())?;
+
+    assert_eq!(file.metadata_segments().count(), 2);
+    assert_eq!(
+        file.metadata_segment("application/json")
+            .map(ByteBuffer::as_slice),
+        Some(small.as_slice())
+    );
+    assert_eq!(
+        file.footer()
+            .metadata_segment("large")
+            .map(ByteBuffer::as_slice),
+        Some(large.as_slice())
+    );
+    assert!(file.metadata_segment("missing").is_none());
+
+    let mut deserializer = crate::Footer::deserializer(bytes.clone(), SESSION.clone())
+        .with_size(bytes.len() as u64)
+        .include_metadata();
+    let footer = match deserializer.deserialize()? {
+        DeserializeStep::Done(footer) => footer,
+        _ => panic!("full file buffer should include all footer segments"),
+    };
+    let json_metadata = footer
+        .metadata_segment("application/json")
+        .vortex_expect("metadata segment");
+    let file_start = bytes.as_slice().as_ptr() as usize;
+    let file_end = file_start + bytes.len();
+    let metadata_start = json_metadata.as_slice().as_ptr() as usize;
+    let metadata_end = metadata_start + json_metadata.len();
+    assert!(metadata_start >= file_start);
+    assert!(metadata_end <= file_end);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_file_metadata_empty_key_rejected() -> VortexResult<()> {
+    let err = metadata_write_error([(String::new(), ByteBuffer::empty())]).await?;
+
+    assert!(err.contains("non-empty"));
+    assert!(err.contains("at most 32 bytes"));
+    assert!(err.contains("at most 16 metadata segments"));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_file_metadata_long_key_rejected() -> VortexResult<()> {
+    let err = metadata_write_error([(
+        "é".repeat((crate::footer::MAX_METADATA_KEY_BYTES / "é".len()) + 1),
+        ByteBuffer::empty(),
+    )])
+    .await?;
+
+    assert!(err.contains("34 bytes"));
+    assert!(err.contains("at most 32 bytes"));
+    assert!(err.contains("at most 16 metadata segments"));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_file_metadata_too_many_segments_rejected() -> VortexResult<()> {
+    let err = metadata_write_error(
+        (0..=crate::footer::MAX_METADATA_SEGMENTS)
+            .map(|idx| (format!("metadata-{idx}"), ByteBuffer::empty()))
+            .collect::<Vec<_>>(),
+    )
+    .await?;
+
+    assert!(err.contains("got 17 metadata segments"));
+    assert!(err.contains("at most 16 metadata segments"));
+    assert!(err.contains("at most 32 bytes"));
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn timestamp_unit_mismatch() -> Result<(), Box<dyn std::error::Error>> {
     // Write file with MILLISECONDS timestamps
diff --git a/vortex-file/src/writer.rs b/vortex-file/src/writer.rs
index 82720c25b29..d804b0bdef1 100644
--- a/vortex-file/src/writer.rs
+++ b/vortex-file/src/writer.rs
@@ -46,6 +46,7 @@ use vortex_layout::sequence::SequentialStreamExt;
 use vortex_session::SessionExt;
 use vortex_session::VortexSession;
 use vortex_session::registry::ReadContext;
+use vortex_utils::aliases::hash_map::HashMap;
 
 use crate::ALLOWED_ENCODINGS;
 use crate::Footer;
@@ -53,6 +54,8 @@ use crate::MAGIC_BYTES;
 use crate::WriteStrategyBuilder;
 use crate::counting::CountingVortexWrite;
 use crate::footer::FileStatistics;
+use crate::footer::MAX_METADATA_KEY_BYTES;
+use crate::footer::MAX_METADATA_SEGMENTS;
 use crate::segments::writer::BufferedSegmentSink;
 
 /// Configure a new writer, which can eventually be used to write an [`ArrayStream`] into a sink
@@ -66,6 +69,7 @@ pub struct VortexWriteOptions {
     exclude_dtype: bool,
     max_variable_length_statistics_size: usize,
     file_statistics: Vec<Stat>,
+    metadata: HashMap<String, ByteBuffer>,
 }
 
 pub trait WriteOptionsSessionExt: SessionExt {
@@ -78,6 +82,7 @@ pub trait WriteOptionsSessionExt: SessionExt {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 }
@@ -92,6 +97,7 @@ impl VortexWriteOptions {
             exclude_dtype: false,
             file_statistics: PRUNING_STATS.to_vec(),
             max_variable_length_statistics_size: 64,
+            metadata: HashMap::default(),
         }
     }
 
@@ -114,6 +120,40 @@ impl VortexWriteOptions {
         self.file_statistics = file_statistics;
         self
     }
+
+    /// Add a user-defined metadata segment to the file.
+    ///
+    /// If the key already exists, the previous segment for that key is replaced.
+    ///
+    /// Metadata limits are validated when writing: keys must be non-empty and at most 32 UTF-8
+    /// bytes, and a file may contain at most 16 user-defined metadata segments. These limits keep
+    /// metadata bookkeeping small because keys and segment locations are stored in the fixed-size
+    /// postscript.
+    pub fn with_metadata_segment(
+        mut self,
+        key: impl Into<String>,
+        metadata: impl Into<ByteBuffer>,
+    ) -> Self {
+        let key = key.into();
+        let metadata = metadata.into();
+        self.metadata.insert(key, metadata);
+        self
+    }
+
+    /// Add user-defined metadata segments to the file.
+    ///
+    /// If a key already exists, the previous segment for that key is replaced.
+    pub fn with_metadata_segments<I, K, B>(mut self, metadata: I) -> Self
+    where
+        I: IntoIterator<Item = (K, B)>,
+        K: Into<String>,
+        B: Into<ByteBuffer>,
+    {
+        for (key, metadata) in metadata {
+            self = self.with_metadata_segment(key, metadata);
+        }
+        self
+    }
 }
 
 impl VortexWriteOptions {
@@ -143,6 +183,8 @@ impl VortexWriteOptions {
         mut write: W,
         stream: SendableArrayStream,
     ) -> VortexResult<WriteSummary> {
+        validate_metadata_segments(&self.metadata)?;
+
         // NOTE(os): Setup an array context that already has all known encodings pre-populated.
         // This is preferred for now over having an empty context here, because only the
         // serialised array order is deterministic. The serialisation of arrays are done
@@ -211,17 +253,21 @@ impl VortexWriteOptions {
         let (layout, segment_specs) = layout_fut.await?;
 
         // Assemble the Footer object now that we have all the segments.
+        let statistics = if self.file_statistics.is_empty() {
+            None
+        } else {
+            Some(FileStatistics::new_with_dtype(
+                file_stats.stats_sets().into(),
+                &dtype,
+            ))
+        };
+        let metadata = Arc::new(self.metadata);
+
         let mut footer = Footer::new(
             Arc::clone(&layout),
             segment_specs,
-            if self.file_statistics.is_empty() {
-                None
-            } else {
-                Some(FileStatistics::new_with_dtype(
-                    file_stats.stats_sets().into(),
-                    &dtype,
-                ))
-            },
+            statistics,
+            metadata,
             ReadContext::new(ctx.to_ids()),
         );
 
@@ -272,6 +318,38 @@ impl VortexWriteOptions {
     }
 }
 
+fn validate_metadata_segments(metadata: &HashMap<String, ByteBuffer>) -> VortexResult<()> {
+    if metadata.len() > MAX_METADATA_SEGMENTS {
+        vortex_bail!(
+            "Vortex files may contain at most {} metadata segments with keys at most {} bytes; got {} metadata segments",
+            MAX_METADATA_SEGMENTS,
+            MAX_METADATA_KEY_BYTES,
+            metadata.len()
+        );
+    }
+
+    for key in metadata.keys() {
+        if key.is_empty() {
+            vortex_bail!(
+                "Vortex metadata keys must be non-empty and at most {} bytes, and files may contain at most {} metadata segments",
+                MAX_METADATA_KEY_BYTES,
+                MAX_METADATA_SEGMENTS
+            );
+        }
+
+        let key_bytes = key.len();
+        if key_bytes > MAX_METADATA_KEY_BYTES {
+            vortex_bail!(
+                "Vortex metadata key {key:?} is {key_bytes} bytes, but keys must be at most {} bytes and files may contain at most {} metadata segments",
+                MAX_METADATA_KEY_BYTES,
+                MAX_METADATA_SEGMENTS
+            );
+        }
+    }
+
+    Ok(())
+}
+
 /// An async API for writing Vortex files.
 pub struct Writer<'w> {
     // The input channel for sending arrays to the writer.
diff --git a/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs b/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
index 9d6e4be1d1c..d45528c96b6 100644
--- a/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
+++ b/vortex-flatbuffers/flatbuffers/vortex-file/footer.fbs
@@ -29,6 +29,14 @@ table Postscript {
     statistics: PostscriptSegment;
     /// Segment containing the 'Footer' flatbuffer (required)
     footer: PostscriptSegment;
+    /// User-defined metadata segments keyed by string.
+    metadata: [PostscriptMetadata];
+}
+
+/// A keyed user-defined metadata segment.
+table PostscriptMetadata {
+    key: string (required);
+    segment: PostscriptSegment (required);
 }
 
 /// A `PostscriptSegment` describes the location of a segment in the file without referencing any
diff --git a/vortex-flatbuffers/public-api.lock b/vortex-flatbuffers/public-api.lock
index 3c37457734a..f799b76d94a 100644
--- a/vortex-flatbuffers/public-api.lock
+++ b/vortex-flatbuffers/public-api.lock
@@ -1672,6 +1672,8 @@ pub enum vortex_flatbuffers::footer::FooterOffset
 
 pub enum vortex_flatbuffers::footer::LayoutSpecOffset
 
+pub enum vortex_flatbuffers::footer::PostscriptMetadataOffset
+
 pub enum vortex_flatbuffers::footer::PostscriptOffset
 
 pub enum vortex_flatbuffers::footer::PostscriptSegmentOffset
@@ -2140,6 +2142,8 @@ pub const vortex_flatbuffers::footer::Postscript<'a>::VT_FOOTER: flatbuffers::pr
 
 pub const vortex_flatbuffers::footer::Postscript<'a>::VT_LAYOUT: flatbuffers::primitives::VOffsetT
 
+pub const vortex_flatbuffers::footer::Postscript<'a>::VT_METADATA: flatbuffers::primitives::VOffsetT
+
 pub const vortex_flatbuffers::footer::Postscript<'a>::VT_STATISTICS: flatbuffers::primitives::VOffsetT
 
 pub fn vortex_flatbuffers::footer::Postscript<'a>::create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::builder::Allocator + 'bldr>(&'mut_bldr mut flatbuffers::builder::FlatBufferBuilder<'bldr, A>, &'args vortex_flatbuffers::footer::PostscriptArgs<'args>) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::Postscript<'bldr>>
@@ -2152,6 +2156,8 @@ pub unsafe fn vortex_flatbuffers::footer::Postscript<'a>::init_from_table(flatbu
 
 pub fn vortex_flatbuffers::footer::Postscript<'a>::layout(&self) -> core::option::Option<vortex_flatbuffers::footer::PostscriptSegment<'a>>
 
+pub fn vortex_flatbuffers::footer::Postscript<'a>::metadata(&self) -> core::option::Option<flatbuffers::vector::Vector<'a, flatbuffers::primitives::ForwardsUOffset<vortex_flatbuffers::footer::PostscriptMetadata<'a>>>>
+
 pub fn vortex_flatbuffers::footer::Postscript<'a>::statistics(&self) -> core::option::Option<vortex_flatbuffers::footer::PostscriptSegment<'a>>
 
 impl core::fmt::Debug for vortex_flatbuffers::footer::Postscript<'_>
@@ -2188,6 +2194,8 @@ pub vortex_flatbuffers::footer::PostscriptArgs::footer: core::option::Option<fla
 
 pub vortex_flatbuffers::footer::PostscriptArgs::layout: core::option::Option<flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'a>>>
 
+pub vortex_flatbuffers::footer::PostscriptArgs::metadata: core::option::Option<flatbuffers::primitives::WIPOffset<flatbuffers::vector::Vector<'a, flatbuffers::primitives::ForwardsUOffset<vortex_flatbuffers::footer::PostscriptMetadata<'a>>>>>
+
 pub vortex_flatbuffers::footer::PostscriptArgs::statistics: core::option::Option<flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'a>>>
 
 impl<'a> core::default::Default for vortex_flatbuffers::footer::PostscriptArgs<'a>
@@ -2204,12 +2212,80 @@ pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::add_footer(&mut
 
 pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::add_layout(&mut self, flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'b>>)
 
+pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::add_metadata(&mut self, flatbuffers::primitives::WIPOffset<flatbuffers::vector::Vector<'b, flatbuffers::primitives::ForwardsUOffset<vortex_flatbuffers::footer::PostscriptMetadata<'b>>>>)
+
 pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::add_statistics(&mut self, flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'b>>)
 
 pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::finish(self) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::Postscript<'a>>
 
 pub fn vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>::new(&'b mut flatbuffers::builder::FlatBufferBuilder<'a, A>) -> vortex_flatbuffers::footer::PostscriptBuilder<'a, 'b, A>
 
+pub struct vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub vortex_flatbuffers::footer::PostscriptMetadata::_tab: flatbuffers::table::Table<'a>
+
+impl<'a> vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub const vortex_flatbuffers::footer::PostscriptMetadata<'a>::VT_KEY: flatbuffers::primitives::VOffsetT
+
+pub const vortex_flatbuffers::footer::PostscriptMetadata<'a>::VT_SEGMENT: flatbuffers::primitives::VOffsetT
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::builder::Allocator + 'bldr>(&'mut_bldr mut flatbuffers::builder::FlatBufferBuilder<'bldr, A>, &'args vortex_flatbuffers::footer::PostscriptMetadataArgs<'args>) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptMetadata<'bldr>>
+
+pub unsafe fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::init_from_table(flatbuffers::table::Table<'a>) -> Self
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::key(&self) -> &'a str
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::segment(&self) -> vortex_flatbuffers::footer::PostscriptSegment<'a>
+
+impl core::fmt::Debug for vortex_flatbuffers::footer::PostscriptMetadata<'_>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'_>::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+
+impl flatbuffers::verifier::Verifiable for vortex_flatbuffers::footer::PostscriptMetadata<'_>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'_>::run_verifier(&mut flatbuffers::verifier::Verifier<'_, '_>, usize) -> core::result::Result<(), flatbuffers::verifier::InvalidFlatbuffer>
+
+impl<'a> core::clone::Clone for vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::clone(&self) -> vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+impl<'a> core::cmp::PartialEq for vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::eq(&self, &vortex_flatbuffers::footer::PostscriptMetadata<'a>) -> bool
+
+impl<'a> core::marker::Copy for vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+impl<'a> core::marker::StructuralPartialEq for vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+impl<'a> flatbuffers::follow::Follow<'a> for vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub type vortex_flatbuffers::footer::PostscriptMetadata<'a>::Inner = vortex_flatbuffers::footer::PostscriptMetadata<'a>
+
+pub unsafe fn vortex_flatbuffers::footer::PostscriptMetadata<'a>::follow(&'a [u8], usize) -> Self::Inner
+
+pub struct vortex_flatbuffers::footer::PostscriptMetadataArgs<'a>
+
+pub vortex_flatbuffers::footer::PostscriptMetadataArgs::key: core::option::Option<flatbuffers::primitives::WIPOffset<&'a str>>
+
+pub vortex_flatbuffers::footer::PostscriptMetadataArgs::segment: core::option::Option<flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'a>>>
+
+impl<'a> core::default::Default for vortex_flatbuffers::footer::PostscriptMetadataArgs<'a>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadataArgs<'a>::default() -> Self
+
+pub struct vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a: 'b, 'b, A: flatbuffers::builder::Allocator + 'a>
+
+impl<'a: 'b, 'b, A: flatbuffers::builder::Allocator + 'a> vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>::add_key(&mut self, flatbuffers::primitives::WIPOffset<&'b str>)
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>::add_segment(&mut self, flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptSegment<'b>>)
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>::finish(self) -> flatbuffers::primitives::WIPOffset<vortex_flatbuffers::footer::PostscriptMetadata<'a>>
+
+pub fn vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>::new(&'b mut flatbuffers::builder::FlatBufferBuilder<'a, A>) -> vortex_flatbuffers::footer::PostscriptMetadataBuilder<'a, 'b, A>
+
 pub struct vortex_flatbuffers::footer::PostscriptSegment<'a>
 
 pub vortex_flatbuffers::footer::PostscriptSegment::_tab: flatbuffers::table::Table<'a>
diff --git a/vortex-flatbuffers/src/generated/footer.rs b/vortex-flatbuffers/src/generated/footer.rs
index 842a151edc7..09c25ee17e7 100644
--- a/vortex-flatbuffers/src/generated/footer.rs
+++ b/vortex-flatbuffers/src/generated/footer.rs
@@ -359,6 +359,7 @@ impl<'a> Postscript<'a> {
   pub const VT_LAYOUT: ::flatbuffers::VOffsetT = 6;
   pub const VT_STATISTICS: ::flatbuffers::VOffsetT = 8;
   pub const VT_FOOTER: ::flatbuffers::VOffsetT = 10;
+  pub const VT_METADATA: ::flatbuffers::VOffsetT = 12;
 
   #[inline]
   pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
@@ -370,6 +371,7 @@ impl<'a> Postscript<'a> {
     args: &'args PostscriptArgs<'args>
   ) -> ::flatbuffers::WIPOffset<Postscript<'bldr>> {
     let mut builder = PostscriptBuilder::new(_fbb);
+    if let Some(x) = args.metadata { builder.add_metadata(x); }
     if let Some(x) = args.footer { builder.add_footer(x); }
     if let Some(x) = args.statistics { builder.add_statistics(x); }
     if let Some(x) = args.layout { builder.add_layout(x); }
@@ -410,6 +412,14 @@ impl<'a> Postscript<'a> {
     // which contains a valid value in this slot
     unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_FOOTER, None)}
   }
+  /// User-defined metadata segments keyed by string.
+  #[inline]
+  pub fn metadata(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'a>>>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata>>>>(Postscript::VT_METADATA, None)}
+  }
 }
 
 impl ::flatbuffers::Verifiable for Postscript<'_> {
@@ -422,6 +432,7 @@ impl ::flatbuffers::Verifiable for Postscript<'_> {
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("layout", Self::VT_LAYOUT, false)?
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("statistics", Self::VT_STATISTICS, false)?
      .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("footer", Self::VT_FOOTER, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<PostscriptMetadata>>>>("metadata", Self::VT_METADATA, false)?
      .finish();
     Ok(())
   }
@@ -431,6 +442,7 @@ pub struct PostscriptArgs<'a> {
     pub layout: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
     pub statistics: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
     pub footer: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
+    pub metadata: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'a>>>>>,
 }
 impl<'a> Default for PostscriptArgs<'a> {
   #[inline]
@@ -440,6 +452,7 @@ impl<'a> Default for PostscriptArgs<'a> {
       layout: None,
       statistics: None,
       footer: None,
+      metadata: None,
     }
   }
 }
@@ -466,6 +479,10 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptBuilder<'a, 'b, A>
     self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_FOOTER, footer);
   }
   #[inline]
+  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Postscript::VT_METADATA, metadata);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptBuilder<'a, 'b, A> {
     let start = _fbb.start_table();
     PostscriptBuilder {
@@ -487,6 +504,123 @@ impl ::core::fmt::Debug for Postscript<'_> {
       ds.field("layout", &self.layout());
       ds.field("statistics", &self.statistics());
       ds.field("footer", &self.footer());
+      ds.field("metadata", &self.metadata());
+      ds.finish()
+  }
+}
+pub enum PostscriptMetadataOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// A keyed user-defined metadata segment.
+pub struct PostscriptMetadata<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for PostscriptMetadata<'a> {
+  type Inner = PostscriptMetadata<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> PostscriptMetadata<'a> {
+  pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
+  pub const VT_SEGMENT: ::flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    PostscriptMetadata { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args PostscriptMetadataArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'bldr>> {
+    let mut builder = PostscriptMetadataBuilder::new(_fbb);
+    if let Some(x) = args.segment { builder.add_segment(x); }
+    if let Some(x) = args.key { builder.add_key(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn key(&self) -> &'a str {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(PostscriptMetadata::VT_KEY, None).unwrap()}
+  }
+  #[inline]
+  pub fn segment(&self) -> PostscriptSegment<'a> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(PostscriptMetadata::VT_SEGMENT, None).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for PostscriptMetadata<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, true)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("segment", Self::VT_SEGMENT, true)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct PostscriptMetadataArgs<'a> {
+    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub segment: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
+}
+impl<'a> Default for PostscriptMetadataArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    PostscriptMetadataArgs {
+      key: None, // required field
+      segment: None, // required field
+    }
+  }
+}
+
+pub struct PostscriptMetadataBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptMetadataBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PostscriptMetadata::VT_KEY, key);
+  }
+  #[inline]
+  pub fn add_segment(&mut self, segment: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(PostscriptMetadata::VT_SEGMENT, segment);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptMetadataBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    PostscriptMetadataBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    self.fbb_.required(o, PostscriptMetadata::VT_KEY,"key");
+    self.fbb_.required(o, PostscriptMetadata::VT_SEGMENT,"segment");
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for PostscriptMetadata<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("PostscriptMetadata");
+      ds.field("key", &self.key());
+      ds.field("segment", &self.segment());
       ds.finish()
   }
 }