diff --git a/libs/scir/src/drivers.rs b/libs/scir/src/drivers.rs
index 1dd3bd59..fb4749f0 100644
--- a/libs/scir/src/drivers.rs
+++ b/libs/scir/src/drivers.rs
@@ -183,7 +183,7 @@ impl Display for Cause {
     }
 }
 
-impl<S: Schema> LibraryBuilder<S> {
+impl<S: Schema + ?Sized> LibraryBuilder<S> {
     /// Perform driver analysis on this library.
     pub fn validate_drivers(&self) -> IssueSet<DriverIssue> {
         let _guard = span!(Level::INFO, "performing driver analysis on SCIR Library").entered();
@@ -240,7 +240,7 @@ impl<S: Schema> LibraryBuilder<S> {
     }
 }
 
-fn analyze_instance<S: Schema>(
+fn analyze_instance<S: Schema + ?Sized>(
     lib: &LibraryBuilder<S>,
     net_states: &mut HashMap<SignalId, Vec<NetState>>,
     inst: &Instance,
diff --git a/libs/scir/src/lib.rs b/libs/scir/src/lib.rs
index 8d679a01..572bee78 100644
--- a/libs/scir/src/lib.rs
+++ b/libs/scir/src/lib.rs
@@ -490,7 +490,7 @@ pub struct LibraryBuilder<S: Schema + ?Sized = NoSchema> {
     top: Option<CellId>,
 }
 
-impl<S: Schema> Default for LibraryBuilder<S> {
+impl<S: Schema + ?Sized> Default for LibraryBuilder<S> {
     fn default() -> Self {
         Self {
             cell_id: 0,
@@ -503,7 +503,7 @@ impl<S: Schema> Default for LibraryBuilder<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl Clone>> Clone for LibraryBuilder<S> {
+impl<S: Schema<Primitive = impl Clone> + ?Sized> Clone for LibraryBuilder<S> {
     fn clone(&self) -> Self {
         Self {
             cell_id: self.cell_id,
@@ -516,7 +516,7 @@ impl<S: Schema<Primitive = impl Clone>> Clone for LibraryBuilder<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for LibraryBuilder<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for LibraryBuilder<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("LibraryBuilder");
         let _ = builder.field("cell_id", &self.cell_id);
@@ -535,7 +535,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for LibraryBui
 /// The contents of the library cannot be mutated.
 pub struct Library<S: Schema + ?Sized = NoSchema>(LibraryBuilder<S>);
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for Library<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for Library<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("Library");
         let _ = builder.field("0", &self.0);
@@ -543,7 +543,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for Library<S>
     }
 }
 
-impl<S: Schema> Clone for Library<S>
+impl<S: Schema + ?Sized> Clone for Library<S>
 where
     LibraryBuilder<S>: Clone,
 {
@@ -552,14 +552,14 @@ where
     }
 }
 
-impl<S: Schema> Deref for Library<S> {
+impl<S: Schema + ?Sized> Deref for Library<S> {
     type Target = LibraryBuilder<S>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl<S: Schema> Library<S> {
+impl<S: Schema + ?Sized> Library<S> {
     /// Converts a [`Library<S>`] to a [`Library<NoSchema>`], throwing an error if there
     /// are any primitives.
     pub fn drop_schema(self) -> Result<Library<NoSchema>, NoSchemaError> {
@@ -570,7 +570,7 @@ impl<S: Schema> Library<S> {
     ///
     /// A [`LibraryBuilder`] is created to indicate that validation must be done again
     /// to ensure errors were not introduced during the conversion.
-    pub fn convert_schema<C: Schema>(self) -> Result<LibraryBuilder<C>, C::Error>
+    pub fn convert_schema<C: Schema + ?Sized>(self) -> Result<LibraryBuilder<C>, C::Error>
     where
         C: FromSchema<S>,
     {
@@ -583,7 +583,7 @@ impl<S: Schema> Library<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl Clone>> Library<S> {
+impl<S: Schema<Primitive = impl Clone> + ?Sized> Library<S> {
     /// Creates a new SCIR library containing only the named cell and its children
     /// from an existing library.
     pub fn from_cell_named(lib: &Self, cell: &str) -> Self {
@@ -833,7 +833,7 @@ impl NetlistCellConversion {
     }
 }
 
-impl<S: Schema> LibraryBuilder<S> {
+impl<S: Schema + ?Sized> LibraryBuilder<S> {
     /// Creates a new, empty library.
     pub fn new() -> Self {
         Self::default()
@@ -1350,7 +1350,7 @@ impl<S: Schema> LibraryBuilder<S> {
         }
     }
 
-    fn convert_inner<C: Schema, E>(
+    fn convert_inner<C: Schema + ?Sized, E>(
         self,
         convert_primitive: fn(<S as Schema>::Primitive) -> Result<<C as Schema>::Primitive, E>,
         convert_instance: fn(&mut Instance, &<S as Schema>::Primitive) -> Result<(), E>,
@@ -1396,7 +1396,7 @@ impl<S: Schema> LibraryBuilder<S> {
     /// Converts a [`LibraryBuilder<S>`] into a [`LibraryBuilder<C>`].
     ///
     /// Instances associated with non-existent primitives will remain unchanged.
-    pub fn convert_schema<C: Schema>(self) -> Result<LibraryBuilder<C>, C::Error>
+    pub fn convert_schema<C: Schema + ?Sized>(self) -> Result<LibraryBuilder<C>, C::Error>
     where
         C: FromSchema<S>,
     {
@@ -1404,7 +1404,7 @@ impl<S: Schema> LibraryBuilder<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl Clone>> LibraryBuilder<S> {
+impl<S: Schema<Primitive = impl Clone> + ?Sized> LibraryBuilder<S> {
     /// Creates a new SCIR library builder containing only the named cell and its children
     /// from an existing library builder.
     pub fn from_cell_named(lib: &Self, cell: &str) -> Self {
diff --git a/libs/scir/src/merge.rs b/libs/scir/src/merge.rs
index 25b1c176..41ebd863 100644
--- a/libs/scir/src/merge.rs
+++ b/libs/scir/src/merge.rs
@@ -10,7 +10,7 @@ pub struct MergedMapping {
     primitives: HashMap<PrimitiveId, PrimitiveId>,
 }
 
-struct Merger<'a, S: Schema> {
+struct Merger<'a, S: Schema + ?Sized> {
     /// Source cell ID -> destination cell ID
     cell_mapping: HashMap<CellId, CellId>,
     /// Source primitive ID -> destination primitive ID
@@ -21,7 +21,7 @@ struct Merger<'a, S: Schema> {
     src: LibraryBuilder<S>,
 }
 
-impl<'a, S: Schema> Merger<'a, S> {
+impl<'a, S: Schema + ?Sized> Merger<'a, S> {
     #[inline]
     fn new(dst: &'a mut LibraryBuilder<S>, src: LibraryBuilder<S>) -> Self {
         Self {
@@ -114,7 +114,7 @@ impl MergedMapping {
     }
 }
 
-impl<S: Schema> LibraryBuilder<S> {
+impl<S: Schema + ?Sized> LibraryBuilder<S> {
     /// Merges another SCIR library into the current library.
     pub fn merge(&mut self, other: Self) -> MergedMapping {
         Merger::new(self, other).merge()
diff --git a/libs/scir/src/schema.rs b/libs/scir/src/schema.rs
index 07f14b9d..5ecd63d7 100644
--- a/libs/scir/src/schema.rs
+++ b/libs/scir/src/schema.rs
@@ -1,16 +1,16 @@
 //! Traits and definitions associated with schemas, or data formats
 //! used for storing SCIR libraries.
 
+use std::convert::Infallible;
 use crate::Instance;
 use arcstr::ArcStr;
 use serde::{Deserialize, Serialize};
-use std::convert::Infallible;
 
 /// A data format for storing SCIR libraries.
 // TODO: Add method of validating primitive instances.
 pub trait Schema {
     /// A primitive used for storing arbitrary data that is opaque to SCIR.
-    type Primitive: Primitive;
+    type Primitive: Primitive + Sized;
 }
 
 /// A primitive of a SCIR schema.
@@ -19,7 +19,7 @@ pub trait Primitive {}
 impl<T> Primitive for T {}
 
 /// A schema that can be converted from another schema.
-pub trait FromSchema<S: Schema>: Schema {
+pub trait FromSchema<S: Schema + ?Sized>: Schema {
     /// The conversion error type.
     type Error;
 
@@ -36,8 +36,8 @@ pub trait FromSchema<S: Schema>: Schema {
     ) -> Result<(), Self::Error>;
 }
 
-impl<S: Schema> FromSchema<S> for S {
-    type Error = Infallible;
+impl<S: Schema + ?Sized> FromSchema<S> for S {
+    type Error = Infallible
 
     fn convert_primitive(
         primitive: <S as Schema>::Primitive,
diff --git a/libs/scir/src/validation.rs b/libs/scir/src/validation.rs
index e6d489b8..e32bc4cd 100644
--- a/libs/scir/src/validation.rs
+++ b/libs/scir/src/validation.rs
@@ -253,7 +253,7 @@ impl Display for Cause {
     }
 }
 
-impl<S: Schema> LibraryBuilder<S> {
+impl<S: Schema + ?Sized> LibraryBuilder<S> {
     /// Check whether or not this library is valid.
     pub fn validate(&self) -> IssueSet<ValidatorIssue> {
         let _guard = span!(Level::INFO, "validating SCIR Library").entered();
diff --git a/libs/spice/src/netlist.rs b/libs/spice/src/netlist.rs
index 3fe7155d..d67e9f75 100644
--- a/libs/spice/src/netlist.rs
+++ b/libs/spice/src/netlist.rs
@@ -3,19 +3,17 @@
 use arcstr::ArcStr;
 use itertools::Itertools;
 use std::collections::HashMap;
-use std::fs::File;
+
 use std::io::{Result, Write};
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
+use std::path::PathBuf;
 
 use crate::{BlackboxElement, Primitive, Spice};
 use scir::schema::Schema;
 use scir::{
     Cell, ChildId, Library, NetlistCellConversion, NetlistLibConversion, SignalInfo, Slice,
 };
-use substrate::context::Context;
-use substrate::schematic::conv::RawLib;
-use substrate::schematic::Schematic;
+
+use substrate::schematic::netlist::ConvertibleNetlister;
 
 /// A netlist include statement.
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
@@ -433,58 +431,16 @@ impl HasSpiceLikeNetlist for Spice {
     }
 }
 
-impl Spice {
-    /// Writes a nestlist of a SPICE library to the provided buffer.
-    pub fn write_scir_netlist<W: Write>(
+impl ConvertibleNetlister<Spice> for Spice {
+    type Error = std::io::Error;
+    type Options<'a> = NetlistOptions<'a>;
+
+    fn write_scir_netlist<W: Write>(
         &self,
         lib: &Library<Spice>,
         out: &mut W,
-        opts: NetlistOptions<'_>,
-    ) -> Result<NetlistLibConversion> {
+        opts: Self::Options<'_>,
+    ) -> std::result::Result<NetlistLibConversion, Self::Error> {
         NetlisterInstance::new(self, lib, out, opts).export()
     }
-    /// Writes a netlist of a SPICE library to a file at the given path.
-    pub fn write_scir_netlist_to_file(
-        &self,
-        lib: &Library<Spice>,
-        path: impl AsRef<Path>,
-        opts: NetlistOptions<'_>,
-    ) -> Result<NetlistLibConversion> {
-        let path = path.as_ref();
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-        let mut f = File::create(path)?;
-        self.write_scir_netlist(lib, &mut f, opts)
-    }
-    /// Writes a SPICE netlist of a Substrate block to the given buffer.
-    pub fn write_block_netlist<B: Schematic<Spice>, W: Write>(
-        &self,
-        ctx: &Context,
-        block: B,
-        out: &mut W,
-        opts: NetlistOptions<'_>,
-    ) -> substrate::error::Result<(RawLib<Spice>, NetlistLibConversion)> {
-        let raw_lib = ctx.export_scir::<Spice, _>(block)?;
-
-        let conv = self
-            .write_scir_netlist(&raw_lib.scir, out, opts)
-            .map_err(Arc::new)?;
-        Ok((raw_lib, conv))
-    }
-    /// Writes a SPICE netlist of a Substrate block to a file at the given path.
-    pub fn write_block_netlist_to_file<B: Schematic<Spice>>(
-        &self,
-        ctx: &Context,
-        block: B,
-        path: impl AsRef<Path>,
-        opts: NetlistOptions<'_>,
-    ) -> substrate::error::Result<(RawLib<Spice>, NetlistLibConversion)> {
-        let path = path.as_ref();
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent).map_err(Arc::new)?;
-        }
-        let mut f = File::create(path).map_err(Arc::new)?;
-        self.write_block_netlist(ctx, block, &mut f, opts)
-    }
 }
diff --git a/substrate/src/context.rs b/substrate/src/context.rs
index 8d7326b3..9004760a 100644
--- a/substrate/src/context.rs
+++ b/substrate/src/context.rs
@@ -281,7 +281,7 @@ impl Context {
     /// - If yes:
     ///     - Retrieve created cell ID, io_data, and handle to cell
     ///     - being generated and return immediately
-    pub(crate) fn generate_schematic_inner<S: Schema, B: Schematic<S>>(
+    pub(crate) fn generate_schematic_inner<S: Schema + ?Sized, B: Schematic<S>>(
         &self,
         block: Arc<B>,
     ) -> SchemaCellHandle<S, B> {
@@ -337,7 +337,11 @@ impl Context {
         }
     }
 
-    fn generate_cross_schematic_inner<S1: Schema, S2: FromSchema<S1>, B: Schematic<S1>>(
+    fn generate_cross_schematic_inner<
+        S1: Schema + ?Sized,
+        S2: FromSchema<S1> + ?Sized,
+        B: Schematic<S1>,
+    >(
         &self,
         block: Arc<B>,
     ) -> SchemaCellHandle<S2, B> {
@@ -369,7 +373,11 @@ impl Context {
     /// Generates a schematic of a block in schema `S1` for use in schema `S2`.
     ///
     /// Can only generate a cross schematic with one layer of [`FromSchema`] indirection.
-    pub fn generate_cross_schematic<S1: Schema, S2: FromSchema<S1>, B: Schematic<S1>>(
+    pub fn generate_cross_schematic<
+        S1: Schema + ?Sized,
+        S2: FromSchema<S1> + ?Sized,
+        B: Schematic<S1>,
+    >(
         &self,
         block: B,
     ) -> SchemaCellHandle<S2, B> {
@@ -379,7 +387,7 @@ impl Context {
     /// Generates a schematic for `block` in the background.
     ///
     /// Returns a handle to the cell being generated.
-    pub fn generate_schematic<S: Schema, T: Schematic<S>>(
+    pub fn generate_schematic<S: Schema + ?Sized, T: Schematic<S>>(
         &self,
         block: T,
     ) -> SchemaCellHandle<S, T> {
@@ -390,7 +398,7 @@ impl Context {
     /// Export the given block and all sub-blocks as a SCIR library.
     ///
     /// Returns a SCIR library and metadata for converting between SCIR and Substrate formats.
-    pub fn export_scir<S: Schema, T: Schematic<S>>(
+    pub fn export_scir<S: Schema + ?Sized, T: Schematic<S>>(
         &self,
         block: T,
     ) -> Result<RawLib<S>, ConvError> {
@@ -558,7 +566,7 @@ impl<PDK: Pdk> PdkContext<PDK> {
     }
 }
 
-fn prepare_cell_builder<S: Schema, T: Block>(
+fn prepare_cell_builder<S: Schema + ?Sized, T: Block>(
     id: CellId,
     context: Context,
     block: &T,
diff --git a/substrate/src/error.rs b/substrate/src/error.rs
index 5a4d76c4..2ec0ccf3 100644
--- a/substrate/src/error.rs
+++ b/substrate/src/error.rs
@@ -52,6 +52,12 @@ pub enum Error {
     UnsupportedPrimitive,
 }
 
+impl From<std::io::Error> for Error {
+    fn from(value: std::io::Error) -> Self {
+        Self::Io(Arc::new(value))
+    }
+}
+
 impl From<LayoutError> for Error {
     fn from(value: LayoutError) -> Self {
         Error::Layout(value)
diff --git a/substrate/src/schematic/conv.rs b/substrate/src/schematic/conv.rs
index a5632368..ffc4d200 100644
--- a/substrate/src/schematic/conv.rs
+++ b/substrate/src/schematic/conv.rs
@@ -16,7 +16,7 @@ use crate::schematic::{ConvertPrimitive, InstancePath, RawCellContents, RawCellK
 use super::{CellId, InstanceId, RawCell};
 
 /// An SCIR library with associated conversion metadata.
-pub struct RawLib<S: Schema> {
+pub struct RawLib<S: Schema + ?Sized> {
     /// The SCIR library.
     pub scir: scir::Library<S>,
     /// Associated conversion metadata.
@@ -374,13 +374,13 @@ pub(crate) struct ScirInstanceConversion {
     instance: ConvertedScirInstance,
 }
 
-pub(crate) struct ScirLibExportContext<S: Schema> {
+pub(crate) struct ScirLibExportContext<S: Schema + ?Sized> {
     lib: LibraryBuilder<S>,
     conv: ScirLibConversionBuilder,
     cell_names: Names<CellId>,
 }
 
-impl<S: Schema> Default for ScirLibExportContext<S> {
+impl<S: Schema + ?Sized> Default for ScirLibExportContext<S> {
     fn default() -> Self {
         Self {
             lib: LibraryBuilder::new(),
@@ -390,7 +390,7 @@ impl<S: Schema> Default for ScirLibExportContext<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl Clone>> Clone for ScirLibExportContext<S> {
+impl<S: Schema<Primitive = impl Clone> + ?Sized> Clone for ScirLibExportContext<S> {
     fn clone(&self) -> Self {
         Self {
             lib: self.lib.clone(),
@@ -400,7 +400,9 @@ impl<S: Schema<Primitive = impl Clone>> Clone for ScirLibExportContext<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ScirLibExportContext<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug
+    for ScirLibExportContext<S>
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("ScirLibExportContext");
         let _ = builder.field("lib", &self.lib);
@@ -410,7 +412,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ScirLibExp
     }
 }
 
-impl<S: Schema> ScirLibExportContext<S> {
+impl<S: Schema + ?Sized> ScirLibExportContext<S> {
     fn new() -> Self {
         Self::default()
     }
@@ -447,7 +449,7 @@ impl ScirCellExportContext {
     }
 }
 
-impl<S: Schema> RawCell<S> {
+impl<S: Schema + ?Sized> RawCell<S> {
     /// The name associated with the given node.
     ///
     /// # Panics
diff --git a/substrate/src/schematic/mod.rs b/substrate/src/schematic/mod.rs
index 3ccd30b1..1fc42f88 100644
--- a/substrate/src/schematic/mod.rs
+++ b/substrate/src/schematic/mod.rs
@@ -1,6 +1,7 @@
 //! Substrate's schematic generator framework.
 
 pub mod conv;
+pub mod netlist;
 pub mod primitives;
 pub mod schema;
 
@@ -44,7 +45,7 @@ pub trait ExportsNestedData: Block {
 }
 
 /// A block that has a schematic associated with the given PDK and schema.
-pub trait Schematic<S: Schema>: ExportsNestedData {
+pub trait Schematic<S: Schema + ?Sized>: ExportsNestedData {
     /// Generates the block's schematic.
     fn schematic(
         &self,
@@ -54,7 +55,7 @@ pub trait Schematic<S: Schema>: ExportsNestedData {
 }
 
 /// A builder for creating a schematic cell.
-pub struct CellBuilder<S: Schema> {
+pub struct CellBuilder<S: Schema + ?Sized> {
     /// The current global context.
     pub(crate) ctx: Context,
     pub(crate) id: CellId,
@@ -73,7 +74,7 @@ pub struct CellBuilder<S: Schema> {
     pub(crate) contents: RawCellContentsBuilder<S>,
 }
 
-impl<S: Schema> CellBuilder<S> {
+impl<S: Schema + ?Sized> CellBuilder<S> {
     pub(crate) fn finish(self) -> RawCell<S> {
         let mut roots = HashMap::with_capacity(self.node_names.len());
         let mut uf = self.node_ctx.into_uf();
@@ -313,7 +314,7 @@ impl<S: Schema> CellBuilder<S> {
     }
 
     /// Creates a [`SubCellBuilder`] for instantiating blocks from schema `S2`.
-    pub fn sub_builder<S2: Schema>(&mut self) -> SubCellBuilder<S, S2>
+    pub fn sub_builder<S2: Schema + ?Sized>(&mut self) -> SubCellBuilder<S, S2>
     where
         S: FromSchema<S2>,
     {
@@ -322,9 +323,12 @@ impl<S: Schema> CellBuilder<S> {
 }
 
 /// A cell builder for instantiating blocks from schema `S2` in schema `S`.
-pub struct SubCellBuilder<'a, S: Schema, S2: Schema>(&'a mut CellBuilder<S>, PhantomData<S2>);
+pub struct SubCellBuilder<'a, S: Schema + ?Sized, S2: Schema + ?Sized>(
+    &'a mut CellBuilder<S>,
+    PhantomData<S2>,
+);
 
-impl<'a, S: FromSchema<S2>, S2: Schema> SubCellBuilder<'a, S, S2> {
+impl<'a, S: FromSchema<S2> + ?Sized, S2: Schema + ?Sized> SubCellBuilder<'a, S, S2> {
     /// Create a new signal with the given name and hardware type.
     #[track_caller]
     pub fn signal<TY: HardwareType>(
@@ -566,13 +570,13 @@ impl<T: ExportsNestedData> CellHandle<T> {
     }
 }
 
-pub(crate) struct SchemaCellCacheValue<S: Schema, B: ExportsNestedData> {
+pub(crate) struct SchemaCellCacheValue<S: Schema + ?Sized, B: ExportsNestedData> {
     pub(crate) raw: Arc<RawCell<S>>,
     pub(crate) cell: Arc<Cell<B>>,
 }
 
 /// A cell handle associated with a schema `S`.
-pub struct SchemaCellHandle<S: Schema, B: ExportsNestedData> {
+pub struct SchemaCellHandle<S: Schema + ?Sized, B: ExportsNestedData> {
     pub(crate) handle: CacheHandle<Result<SchemaCellCacheValue<S, B>>>,
     pub(crate) cell: CellHandle<B>,
 }
@@ -598,7 +602,7 @@ impl<S: Schema, B: ExportsNestedData> SchemaCellHandle<S, B> {
     }
 }
 
-impl<S: Schema, B: ExportsNestedData> Deref for SchemaCellHandle<S, B> {
+impl<S: Schema + ?Sized, B: ExportsNestedData> Deref for SchemaCellHandle<S, B> {
     type Target = CellHandle<B>;
 
     fn deref(&self) -> &Self::Target {
@@ -606,7 +610,7 @@ impl<S: Schema, B: ExportsNestedData> Deref for SchemaCellHandle<S, B> {
     }
 }
 
-impl<S: Schema, B: ExportsNestedData> Clone for SchemaCellHandle<S, B> {
+impl<S: Schema + ?Sized, B: ExportsNestedData> Clone for SchemaCellHandle<S, B> {
     fn clone(&self) -> Self {
         Self {
             handle: self.handle.clone(),
@@ -815,12 +819,12 @@ impl<B: Block> Clone for CellMetadata<B> {
     }
 }
 
-pub(crate) struct CellCacheKey<B, S> {
+pub(crate) struct CellCacheKey<B, S: ?Sized> {
     pub(crate) block: Arc<B>,
     pub(crate) phantom: PhantomData<S>,
 }
 
-impl<B, S> Clone for CellCacheKey<B, S> {
+impl<B, S: ?Sized> Clone for CellCacheKey<B, S> {
     fn clone(&self) -> Self {
         Self {
             block: self.block.clone(),
@@ -829,22 +833,22 @@ impl<B, S> Clone for CellCacheKey<B, S> {
     }
 }
 
-impl<B: PartialEq, S> PartialEq for CellCacheKey<B, S> {
+impl<B: PartialEq, S: ?Sized> PartialEq for CellCacheKey<B, S> {
     fn eq(&self, other: &Self) -> bool {
         self.block.eq(&other.block)
     }
 }
 
-impl<B: Eq, S> Eq for CellCacheKey<B, S> {}
+impl<B: Eq, S: ?Sized> Eq for CellCacheKey<B, S> {}
 
-impl<B: Hash, S> Hash for CellCacheKey<B, S> {
+impl<B: Hash, S: ?Sized> Hash for CellCacheKey<B, S> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.block.hash(state)
     }
 }
 
 /// A key for a block that was generated in schema `S1` and converted to schema `S2`.
-pub(crate) type ConvCacheKey<B, S1, S2> = CellCacheKey<B, (S1, S2)>;
+pub(crate) type ConvCacheKey<B, S1, S2> = CellCacheKey<B, (PhantomData<S1>, S2)>;
 
 /// A path to an instance from a top level cell.
 ///
@@ -977,14 +981,16 @@ impl<T: HasNestedView> HasNestedView for Option<T> {
 
 /// A raw (weakly-typed) instance of a cell.
 #[allow(dead_code)]
-pub(crate) struct RawInstanceBuilder<S: Schema> {
+pub(crate) struct RawInstanceBuilder<S: Schema + ?Sized> {
     id: InstanceId,
     name: ArcStr,
     connections: Vec<Node>,
     child: CacheHandle<Arc<RawCell<S>>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawInstanceBuilder<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug
+    for RawInstanceBuilder<S>
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("RawInstanceBuilder");
         let _ = builder.field("id", &self.id);
@@ -995,7 +1001,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawInstanc
     }
 }
 
-impl<S: Schema> RawInstanceBuilder<S> {
+impl<S: Schema + ?Sized> RawInstanceBuilder<S> {
     fn build(self) -> RawInstance<S> {
         RawInstance {
             id: self.id,
@@ -1008,14 +1014,14 @@ impl<S: Schema> RawInstanceBuilder<S> {
 
 /// A raw (weakly-typed) instance of a cell.
 #[allow(dead_code)]
-pub(crate) struct RawInstance<S: Schema> {
+pub(crate) struct RawInstance<S: Schema + ?Sized> {
     id: InstanceId,
     name: ArcStr,
     connections: Vec<Node>,
     child: Arc<RawCell<S>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawInstance<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for RawInstance<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("RawInstance");
         let _ = builder.field("id", &self.id);
@@ -1026,7 +1032,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawInstanc
     }
 }
 
-impl<S: Schema> Clone for RawInstance<S> {
+impl<S: Schema + ?Sized> Clone for RawInstance<S> {
     fn clone(&self) -> Self {
         Self {
             id: self.id,
@@ -1037,8 +1043,8 @@ impl<S: Schema> Clone for RawInstance<S> {
     }
 }
 
-impl<S: Schema> RawInstance<S> {
-    fn convert_schema<S2: FromSchema<S>>(self) -> Result<RawInstance<S2>> {
+impl<S: Schema + ?Sized> RawInstance<S> {
+    fn convert_schema<S2: FromSchema<S> + ?Sized>(self) -> Result<RawInstance<S2>> {
         Ok(RawInstance {
             id: self.id,
             name: self.name,
@@ -1054,7 +1060,7 @@ impl<S: Schema> RawInstance<S> {
 /// should not have any public methods.
 #[allow(dead_code)]
 #[doc(hidden)]
-pub struct RawCell<S: Schema> {
+pub struct RawCell<S: Schema + ?Sized> {
     id: CellId,
     pub(crate) name: ArcStr,
     ports: Vec<Port>,
@@ -1066,7 +1072,7 @@ pub struct RawCell<S: Schema> {
     contents: RawCellContents<S>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCell<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for RawCell<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("RawCell");
         let _ = builder.field("id", &self.id);
@@ -1081,7 +1087,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCell<S>
     }
 }
 
-impl<S: Schema> Clone for RawCell<S> {
+impl<S: Schema + ?Sized> Clone for RawCell<S> {
     fn clone(&self) -> Self {
         Self {
             id: self.id,
@@ -1096,8 +1102,8 @@ impl<S: Schema> Clone for RawCell<S> {
     }
 }
 
-impl<S: Schema> RawCell<S> {
-    pub(crate) fn convert_schema<S2: FromSchema<S>>(self) -> Result<RawCell<S2>> {
+impl<S: Schema + ?Sized> RawCell<S> {
+    pub(crate) fn convert_schema<S2: FromSchema<S> + ?Sized>(self) -> Result<RawCell<S2>> {
         Ok(RawCell {
             id: self.id,
             name: self.name,
@@ -1115,7 +1121,7 @@ impl<S: Schema> RawCell<S> {
 pub(crate) type RawCellContentsBuilder<S> =
     RawCellKind<RawCellInnerBuilder<S>, ScirBinding<S>, PrimitiveBinding<S>, ConvertedPrimitive<S>>;
 
-impl<S: Schema> RawCellContentsBuilder<S> {
+impl<S: Schema + ?Sized> RawCellContentsBuilder<S> {
     fn build(self) -> RawCellContents<S> {
         match self {
             RawCellContentsBuilder::Cell(b) => RawCellContents::Cell(b.build()),
@@ -1130,8 +1136,8 @@ impl<S: Schema> RawCellContentsBuilder<S> {
 pub(crate) type RawCellContents<S> =
     RawCellKind<RawCellInner<S>, ScirBinding<S>, PrimitiveBinding<S>, ConvertedPrimitive<S>>;
 
-impl<S: Schema> RawCellContents<S> {
-    fn convert_schema<S2: FromSchema<S>>(self) -> Result<RawCellContents<S2>> {
+impl<S: Schema + ?Sized> RawCellContents<S> {
+    fn convert_schema<S2: FromSchema<S> + ?Sized>(self) -> Result<RawCellContents<S2>> {
         Ok(match self {
             RawCellContents::Cell(c) => RawCellContents::Cell(c.convert_schema()?),
             RawCellContents::Scir(s) => RawCellContents::Scir(ScirBinding {
@@ -1166,13 +1172,15 @@ impl<S: Schema> RawCellContents<S> {
     }
 }
 
-pub(crate) trait ConvertPrimitive<S: Schema>: Any + Send + Sync {
+pub(crate) trait ConvertPrimitive<S: Schema + ?Sized>: Any + Send + Sync {
     fn convert_primitive(&self) -> Result<<S as Schema>::Primitive>;
     fn convert_instance(&self, inst: &mut scir::Instance) -> Result<()>;
     fn port_map(&self) -> &HashMap<ArcStr, Vec<Node>>;
 }
 
-impl<S1: FromSchema<S2>, S2: Schema> ConvertPrimitive<S1> for PrimitiveBinding<S2> {
+impl<S1: FromSchema<S2> + ?Sized, S2: Schema + ?Sized> ConvertPrimitive<S1>
+    for PrimitiveBinding<S2>
+{
     // TODO: Improve error handling
     fn convert_primitive(&self) -> Result<<S1 as Schema>::Primitive> {
         <S1 as scir::schema::FromSchema<S2>>::convert_primitive(self.primitive.clone())
@@ -1187,7 +1195,9 @@ impl<S1: FromSchema<S2>, S2: Schema> ConvertPrimitive<S1> for PrimitiveBinding<S
     }
 }
 
-impl<S1: FromSchema<S2>, S2: Schema> ConvertPrimitive<S1> for ConvertedPrimitive<S2> {
+impl<S1: FromSchema<S2> + ?Sized, S2: Schema + ?Sized> ConvertPrimitive<S1>
+    for ConvertedPrimitive<S2>
+{
     // TODO: Improve error handling
     fn convert_primitive(&self) -> Result<<S1 as Schema>::Primitive> {
         <S1 as scir::schema::FromSchema<S2>>::convert_primitive(self.original.convert_primitive()?)
@@ -1205,12 +1215,12 @@ impl<S1: FromSchema<S2>, S2: Schema> ConvertPrimitive<S1> for ConvertedPrimitive
 
 /// A binding to a schema primitive that can be used to define
 /// a Substrate schematic.
-pub struct PrimitiveBinding<S: Schema> {
+pub struct PrimitiveBinding<S: Schema + ?Sized> {
     pub(crate) primitive: <S as Schema>::Primitive,
     pub(crate) port_map: HashMap<ArcStr, Vec<Node>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for PrimitiveBinding<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for PrimitiveBinding<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("Primitive");
         let _ = builder.field("primitive", &self.primitive);
@@ -1219,7 +1229,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for PrimitiveB
     }
 }
 
-impl<S: Schema> Clone for PrimitiveBinding<S> {
+impl<S: Schema + ?Sized> Clone for PrimitiveBinding<S> {
     fn clone(&self) -> Self {
         Self {
             primitive: self.primitive.clone(),
@@ -1243,12 +1253,14 @@ impl<S: Schema> PrimitiveBinding<S> {
     }
 }
 
-pub(crate) struct ConvertedPrimitive<S: Schema> {
+pub(crate) struct ConvertedPrimitive<S: Schema + ?Sized> {
     converted: <S as Schema>::Primitive,
     original: Arc<dyn ConvertPrimitive<S>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ConvertedPrimitive<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug
+    for ConvertedPrimitive<S>
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("ConvertedPrimitive");
         let _ = builder.field("converted", &self.converted);
@@ -1256,7 +1268,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ConvertedP
     }
 }
 
-impl<S: Schema> Clone for ConvertedPrimitive<S> {
+impl<S: Schema + ?Sized> Clone for ConvertedPrimitive<S> {
     fn clone(&self) -> Self {
         Self {
             converted: self.converted.clone(),
@@ -1265,7 +1277,7 @@ impl<S: Schema> Clone for ConvertedPrimitive<S> {
     }
 }
 
-impl<S: Schema> ConvertedPrimitive<S> {
+impl<S: Schema + ?Sized> ConvertedPrimitive<S> {
     pub(crate) fn port_map(&self) -> &HashMap<ArcStr, Vec<Node>> {
         self.original.port_map()
     }
@@ -1283,12 +1295,14 @@ pub(crate) enum RawCellKind<C, S, P, CP> {
     ConvertedPrimitive(CP),
 }
 
-pub(crate) struct RawCellInnerBuilder<S: Schema> {
+pub(crate) struct RawCellInnerBuilder<S: Schema + ?Sized> {
     pub(crate) next_instance_id: InstanceId,
     pub(crate) instances: Vec<RawInstanceBuilder<S>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCellInnerBuilder<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug
+    for RawCellInnerBuilder<S>
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("RawCellInnerBuilder");
         let _ = builder.field("next_instance_id", &self.next_instance_id);
@@ -1297,7 +1311,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCellInn
     }
 }
 
-impl<S: Schema> Default for RawCellInnerBuilder<S> {
+impl<S: Schema + ?Sized> Default for RawCellInnerBuilder<S> {
     fn default() -> Self {
         Self {
             next_instance_id: Default::default(),
@@ -1306,7 +1320,7 @@ impl<S: Schema> Default for RawCellInnerBuilder<S> {
     }
 }
 
-impl<S: Schema> RawCellInnerBuilder<S> {
+impl<S: Schema + ?Sized> RawCellInnerBuilder<S> {
     fn build(self) -> RawCellInner<S> {
         RawCellInner {
             instances: self
@@ -1318,11 +1332,11 @@ impl<S: Schema> RawCellInnerBuilder<S> {
     }
 }
 
-pub(crate) struct RawCellInner<S: Schema> {
+pub(crate) struct RawCellInner<S: Schema + ?Sized> {
     pub(crate) instances: Vec<RawInstance<S>>,
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCellInner<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for RawCellInner<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("RawCellInner");
         let _ = builder.field("instances", &self.instances);
@@ -1330,7 +1344,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for RawCellInn
     }
 }
 
-impl<S: Schema> Clone for RawCellInner<S> {
+impl<S: Schema + ?Sized> Clone for RawCellInner<S> {
     fn clone(&self) -> Self {
         Self {
             instances: self.instances.clone(),
@@ -1338,8 +1352,8 @@ impl<S: Schema> Clone for RawCellInner<S> {
     }
 }
 
-impl<S: Schema> RawCellInner<S> {
-    fn convert_schema<S2: FromSchema<S>>(self) -> Result<RawCellInner<S2>> {
+impl<S: Schema + ?Sized> RawCellInner<S> {
+    fn convert_schema<S2: FromSchema<S> + ?Sized>(self) -> Result<RawCellInner<S2>> {
         Ok(RawCellInner {
             instances: self
                 .instances
@@ -1351,13 +1365,13 @@ impl<S: Schema> RawCellInner<S> {
 }
 
 /// A binding to a cell within a SCIR library that can be used to define a Substrate schematic.
-pub struct ScirBinding<S: Schema> {
+pub struct ScirBinding<S: Schema + ?Sized> {
     pub(crate) lib: scir::Library<S>,
     pub(crate) cell: scir::CellId,
     pub(crate) port_map: HashMap<ArcStr, Vec<Node>>,
 }
 
-impl<S: Schema<Primitive = impl Clone>> Clone for ScirBinding<S> {
+impl<S: Schema<Primitive = impl Clone> + ?Sized> Clone for ScirBinding<S> {
     fn clone(&self) -> Self {
         Self {
             lib: self.lib.clone(),
@@ -1367,7 +1381,7 @@ impl<S: Schema<Primitive = impl Clone>> Clone for ScirBinding<S> {
     }
 }
 
-impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ScirBinding<S> {
+impl<S: Schema<Primitive = impl std::fmt::Debug> + ?Sized> std::fmt::Debug for ScirBinding<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut builder = f.debug_struct("ScirCellInner");
         let _ = builder.field("lib", &self.lib);
@@ -1376,7 +1390,7 @@ impl<S: Schema<Primitive = impl std::fmt::Debug>> std::fmt::Debug for ScirBindin
     }
 }
 
-impl<S: Schema> ScirBinding<S> {
+impl<S: Schema + ?Sized> ScirBinding<S> {
     /// Creates a new [`ScirBinding`] corresponding to the given cell in
     /// SCIR library `lib`.
     ///
@@ -1413,7 +1427,9 @@ impl<S: Schema> ScirBinding<S> {
     }
 
     /// Converts the underlying SCIR library to schema `S2`.
-    pub fn convert_schema<S2: FromSchema<S>>(self) -> substrate::error::Result<ScirBinding<S2>> {
+    pub fn convert_schema<S2: FromSchema<S> + ?Sized>(
+        self,
+    ) -> substrate::error::Result<ScirBinding<S2>> {
         Ok(ScirBinding {
             //  TODO: More descriptive error.
             lib: self
diff --git a/substrate/src/schematic/netlist.rs b/substrate/src/schematic/netlist.rs
new file mode 100644
index 00000000..3d314e46
--- /dev/null
+++ b/substrate/src/schematic/netlist.rs
@@ -0,0 +1,85 @@
+//! Netlist export.
+
+use crate::context::Context;
+use crate::schematic::conv::RawLib;
+use crate::schematic::Schematic;
+use scir::{Library, NetlistLibConversion};
+use std::io::Write;
+use std::path::Path;
+use std::sync::Arc;
+use substrate::schematic::schema::Schema;
+
+/// A netlister that tracks how cells and instances are translated between SCIR and the output netlist format.
+pub trait ConvertibleNetlister<S: Schema + ?Sized> {
+    /// The error type returned when writing out a SCIR netlist.
+    type Error: Into<substrate::error::Error>;
+
+    /// The netlist options type.
+    ///
+    /// Many netlisters accept options, allowing the user to configure things like
+    /// netlist indentation, naming conventions, etc. This is the type of the object
+    /// that stores those options.
+    type Options<'a>;
+
+    /// Writes a netlist of a SCIR library to the provided output stream.
+    fn write_scir_netlist<W: Write>(
+        &self,
+        lib: &Library<S>,
+        out: &mut W,
+        opts: Self::Options<'_>,
+    ) -> Result<NetlistLibConversion, Self::Error>;
+
+    /// Writes a netlist of a SCIR library to a file at the given path.
+    ///
+    /// The file and any parent directories will be created if necessary.
+    fn write_scir_netlist_to_file(
+        &self,
+        lib: &Library<S>,
+        path: impl AsRef<Path>,
+        opts: Self::Options<'_>,
+    ) -> substrate::error::Result<NetlistLibConversion> {
+        let path = path.as_ref();
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(Arc::new)?;
+        }
+        let mut f = std::fs::File::create(path).map_err(Arc::new)?;
+        let conv = self
+            .write_scir_netlist(lib, &mut f, opts)
+            .map_err(|e| e.into())?;
+        Ok(conv)
+    }
+
+    /// Writes a netlist of a Substrate block to the given output stream.
+    fn write_netlist<B: Schematic<S>, W: Write>(
+        &self,
+        ctx: &Context,
+        block: B,
+        out: &mut W,
+        opts: Self::Options<'_>,
+    ) -> substrate::error::Result<(RawLib<S>, NetlistLibConversion)> {
+        let raw_lib = ctx.export_scir::<S, _>(block)?;
+
+        let conv = self
+            .write_scir_netlist(&raw_lib.scir, out, opts)
+            .map_err(|e| e.into())?;
+        Ok((raw_lib, conv))
+    }
+
+    /// Writes a netlist of a Substrate block to a file at the given path.
+    ///
+    /// The file and any parent directories will be created if necessary.
+    fn write_netlist_to_file<B: Schematic<S>>(
+        &self,
+        ctx: &Context,
+        block: B,
+        path: impl AsRef<Path>,
+        opts: Self::Options<'_>,
+    ) -> substrate::error::Result<(RawLib<S>, NetlistLibConversion)> {
+        let path = path.as_ref();
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).map_err(Arc::new)?;
+        }
+        let mut f = std::fs::File::create(path).map_err(Arc::new)?;
+        self.write_netlist(ctx, block, &mut f, opts)
+    }
+}
diff --git a/substrate/src/schematic/schema.rs b/substrate/src/schematic/schema.rs
index 6ba81938..26f2d80b 100644
--- a/substrate/src/schematic/schema.rs
+++ b/substrate/src/schematic/schema.rs
@@ -27,6 +27,9 @@ impl<T: Clone + Send + Sync + Any> Primitive for T {}
 ///
 /// This trait should never be directly implemented. Implementing [`scir::schema::FromSchema`]
 /// should suffice provided that the necessary trait bounds are satisfied.
-pub trait FromSchema<S: Schema>: Schema + scir::schema::FromSchema<S> {}
+pub trait FromSchema<S: Schema + ?Sized>: Schema + scir::schema::FromSchema<S> {}
 
-impl<S1: Schema, S2: Schema + scir::schema::FromSchema<S1>> FromSchema<S1> for S2 {}
+impl<S1: Schema + ?Sized, S2: Schema + ?Sized + scir::schema::FromSchema<S1>> FromSchema<S1>
+    for S2
+{
+}
diff --git a/tests/src/hard_macro.rs b/tests/src/hard_macro.rs
index e99c4bf7..092b9b25 100644
--- a/tests/src/hard_macro.rs
+++ b/tests/src/hard_macro.rs
@@ -11,6 +11,7 @@ use spice::Spice;
 use substrate::block::Block;
 use substrate::io::schematic::HardwareType;
 use substrate::layout::Layout;
+use substrate::schematic::netlist::ConvertibleNetlister;
 use substrate::schematic::{CellBuilder, ExportsNestedData, Schematic};
 use test_log::test;
 
diff --git a/tests/src/netlist.rs b/tests/src/netlist.rs
index fad3370d..6b340664 100644
--- a/tests/src/netlist.rs
+++ b/tests/src/netlist.rs
@@ -5,6 +5,7 @@ use spectre::Spectre;
 use spice::netlist::{NetlistKind, NetlistOptions, NetlisterInstance};
 use spice::{BlackboxContents, BlackboxElement, Spice};
 use std::collections::HashMap;
+use substrate::schematic::netlist::ConvertibleNetlister;
 use substrate::schematic::schema::Schema;
 
 pub(crate) trait HasRes2: Schema {
diff --git a/tools/spectre/src/lib.rs b/tools/spectre/src/lib.rs
index a49464b3..16cfeff4 100644
--- a/tools/spectre/src/lib.rs
+++ b/tools/spectre/src/lib.rs
@@ -35,6 +35,7 @@ use substrate::execute::Executor;
 use substrate::io::schematic::HardwareType;
 use substrate::io::schematic::NodePath;
 use substrate::schematic::conv::ConvertedNodePath;
+use substrate::schematic::netlist::ConvertibleNetlister;
 use substrate::schematic::primitives::{Capacitor, RawInstance, Resistor};
 use substrate::schematic::schema::Schema;
 use substrate::schematic::{CellBuilder, PrimitiveBinding, Schematic};
@@ -412,6 +413,20 @@ impl CacheableWithState<CachedSimState> for CachedSim {
     }
 }
 
+impl ConvertibleNetlister<Spectre> for Spectre {
+    type Error = std::io::Error;
+    type Options<'a> = NetlistOptions<'a>;
+
+    fn write_scir_netlist<W: Write>(
+        &self,
+        lib: &Library<Spectre>,
+        out: &mut W,
+        opts: Self::Options<'_>,
+    ) -> std::result::Result<NetlistLibConversion, Self::Error> {
+        NetlisterInstance::new(self, lib, out, opts).export()
+    }
+}
+
 impl Spectre {
     fn simulate(
         &self,
@@ -438,16 +453,14 @@ impl Spectre {
         saves.sort();
         ics.sort();
 
-        let netlister = NetlisterInstance::new(
-            self,
+        let conv = self.write_scir_netlist(
             &ctx.lib.scir,
             &mut w,
             NetlistOptions::new(
                 NetlistKind::Testbench(RenameGround::Yes("0".into())),
                 &includes,
             ),
-        );
-        let conv = netlister.export()?;
+        )?;
 
         writeln!(w)?;
         for save in saves {