diff --git a/crates/cpu/src/config.rs b/crates/cpu/src/config.rs
index a7dd7d9..cf2fd08 100644
--- a/crates/cpu/src/config.rs
+++ b/crates/cpu/src/config.rs
@@ -163,3 +163,15 @@ pub type CpuConfigFetchWidthInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;
 
 #[hdl(get(|c| c.rob_size.get()))]
 pub type CpuConfigRobSize<C: PhantomConstGet<CpuConfig>> = DynSize;
+
+pub trait PhantomConstCpuConfig:
+    PhantomConstGet<CpuConfig>
+    + Into<PhantomConst<CpuConfig>>
+    + From<PhantomConst<CpuConfig>>
+    + Type
+    + ToSimValue<Type = Self>
+    + ToExpr<Type = Self>
+{
+}
+
+impl PhantomConstCpuConfig for PhantomConst<CpuConfig> {}
diff --git a/crates/cpu/src/next_pc.rs b/crates/cpu/src/next_pc.rs
index 45c3db5..e079640 100644
--- a/crates/cpu/src/next_pc.rs
+++ b/crates/cpu/src/next_pc.rs
@@ -14,7 +14,7 @@
 use crate::{
     config::{
         CpuConfig, CpuConfigFetchWidth, CpuConfigMaxFetchesInFlight, CpuConfigRobSize,
-        TwiceCpuConfigFetchWidth,
+        PhantomConstCpuConfig, TwiceCpuConfigFetchWidth,
     },
     util::array_vec::ArrayVec,
 };
@@ -115,7 +115,7 @@ pub struct RetireToNextPcInterfacePerInsn<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl SimValueDefault for RetireToNextPcInterfacePerInsn<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for RetireToNextPcInterfacePerInsn<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -159,7 +159,7 @@ pub struct DecodeToPostDecodeInterfaceInner<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl SimValueDefault for DecodeToPostDecodeInterfaceInner<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for DecodeToPostDecodeInterfaceInner<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { insns, config } = self;
@@ -204,150 +204,383 @@ struct Cancel<C: PhantomConstGet<CpuConfig>> {
 }
 
 /// the output of [`Stage::run`].
-/// when cancelling operations, the returned [`StageOutput.cancel`] should be the state after
-/// running all operations returned in [`StageOutput.output`].
+/// when cancelling operations, the returned [`StageRunOutput.cancel`] should be the state after
+/// running all operations returned in [`StageRunOutput.output`].
 #[hdl(no_static)]
-struct StageOutput<Output, MaxOutputCount: Size, C: PhantomConstGet<CpuConfig>> {
-    outputs: ArrayVec<Output, MaxOutputCount>,
+struct StageRunOutput<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig, S: Type + Stage<C>> {
+    outputs: ArrayVec<StageOutput<C, S>, StageMaxOutputsPerStep<C, S>>,
     /// when set to [`HdlSome`], [`Stage::cancel`] is called on all previous stages
     cancel: HdlOption<Cancel<C>>,
 }
 
-trait Stage: Type + SimValueDefault + ResetSteps {
-    type Input: Type;
+trait Stages<C: PhantomConstCpuConfig>: Type {
+    type Outputs: Type + SimValueDefault;
+    type SimValueOutputQueueRefs<'a>: 'a + Copy;
+    type SimValueOutputQueueMuts<'a>: 'a;
+    fn outputs_ty(config: C) -> Self::Outputs;
+    fn reborrow_output_queues_as_refs<'a>(
+        output_queues: &'a Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueRefs<'a>;
+    fn reborrow_output_queue_muts<'a>(
+        output_queues: &'a mut Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueMuts<'a>;
+    fn peek_output_queues(
+        output_queues: Self::SimValueOutputQueueRefs<'_>,
+        max_peek_len: usize,
+    ) -> impl Iterator<Item = SimValue<Self::Outputs>>;
+    /// pops all output queues; if this function returns `None`, none of the output queues will be modified
+    fn pop_output_queues(
+        output_queues: Self::SimValueOutputQueueMuts<'_>,
+    ) -> Option<SimValue<Self::Outputs>>;
+    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V);
+}
+
+impl<C: PhantomConstCpuConfig> Stages<C> for () {
+    type Outputs = ();
+    type SimValueOutputQueueRefs<'a> = ();
+    type SimValueOutputQueueMuts<'a> = ();
+    fn outputs_ty(_config: C) -> Self::Outputs {
+        ()
+    }
+    fn reborrow_output_queues_as_refs<'a>(
+        output_queues: &'a Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueRefs<'a> {
+        let () = output_queues;
+        ()
+    }
+    fn reborrow_output_queue_muts<'a>(
+        output_queues: &'a mut Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueMuts<'a> {
+        let () = output_queues;
+        ()
+    }
+    #[hdl]
+    fn peek_output_queues(
+        output_queues: Self::SimValueOutputQueueRefs<'_>,
+        max_peek_len: usize,
+    ) -> impl Iterator<Item = SimValue<Self::Outputs>> {
+        let () = output_queues;
+        std::iter::repeat_n(
+            #[hdl(sim)]
+            (),
+            max_peek_len,
+        )
+    }
+    #[hdl]
+    fn pop_output_queues(
+        output_queues: Self::SimValueOutputQueueMuts<'_>,
+    ) -> Option<SimValue<Self::Outputs>> {
+        let () = output_queues;
+        Some(
+            #[hdl(sim)]
+            (),
+        )
+    }
+    #[hdl]
+    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, _visitor: &mut V) {
+        #[hdl(sim)]
+        let () = this;
+    }
+}
+
+impl<C: PhantomConstCpuConfig, S1: Stage<C>> Stages<C> for S1 {
+    type Outputs = S1::Output;
+    type SimValueOutputQueueRefs<'a> =
+        &'a SimValue<Queue<StageOutput<C, S1>, StageOutputQueueSize<C, S1>>>;
+    type SimValueOutputQueueMuts<'a> =
+        &'a mut SimValue<Queue<StageOutput<C, S1>, StageOutputQueueSize<C, S1>>>;
+    fn outputs_ty(config: C) -> Self::Outputs {
+        S1::output_ty(config)
+    }
+    fn reborrow_output_queues_as_refs<'a>(
+        output_queues: &'a Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueRefs<'a> {
+        output_queues
+    }
+    fn reborrow_output_queue_muts<'a>(
+        output_queues: &'a mut Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueMuts<'a> {
+        output_queues
+    }
+    fn peek_output_queues(
+        output_queues: Self::SimValueOutputQueueRefs<'_>,
+        max_peek_len: usize,
+    ) -> impl Iterator<Item = SimValue<Self::Outputs>> {
+        Queue::peek_iter(output_queues).take(max_peek_len)
+    }
+    fn pop_output_queues(
+        output_queues: Self::SimValueOutputQueueMuts<'_>,
+    ) -> Option<SimValue<Self::Outputs>> {
+        Queue::pop(output_queues)
+    }
+    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V) {
+        visitor.visit(this);
+    }
+}
+
+impl<C: PhantomConstCpuConfig, S1: Stage<C>, S2: Stage<C>> Stages<C> for (S1, S2) {
+    type Outputs = (S1::Output, S2::Output);
+    type SimValueOutputQueueRefs<'a> = (
+        &'a SimValue<Queue<StageOutput<C, S1>, StageOutputQueueSize<C, S1>>>,
+        &'a SimValue<Queue<StageOutput<C, S2>, StageOutputQueueSize<C, S2>>>,
+    );
+    type SimValueOutputQueueMuts<'a> = (
+        &'a mut SimValue<Queue<StageOutput<C, S1>, StageOutputQueueSize<C, S1>>>,
+        &'a mut SimValue<Queue<StageOutput<C, S2>, StageOutputQueueSize<C, S2>>>,
+    );
+    fn outputs_ty(config: C) -> Self::Outputs {
+        (S1::output_ty(config), S2::output_ty(config))
+    }
+    fn reborrow_output_queues_as_refs<'a>(
+        output_queues: &'a Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueRefs<'a> {
+        let (s1, s2) = output_queues;
+        (s1, s2)
+    }
+    fn reborrow_output_queue_muts<'a>(
+        output_queues: &'a mut Self::SimValueOutputQueueMuts<'_>,
+    ) -> Self::SimValueOutputQueueMuts<'a> {
+        let (s1, s2) = output_queues;
+        (s1, s2)
+    }
+    fn peek_output_queues(
+        output_queues: Self::SimValueOutputQueueRefs<'_>,
+        max_peek_len: usize,
+    ) -> impl Iterator<Item = SimValue<Self::Outputs>> {
+        let (s1, s2) = output_queues;
+        Queue::peek_iter(s1)
+            .zip(Queue::peek_iter(s2))
+            .take(max_peek_len)
+            .map(ToSimValue::into_sim_value)
+    }
+    #[hdl]
+    fn pop_output_queues(
+        output_queues: Self::SimValueOutputQueueMuts<'_>,
+    ) -> Option<SimValue<Self::Outputs>> {
+        let (s1, s2) = output_queues;
+        // make sure to only pop if all pops will succeed
+        if Queue::is_empty(s1) || Queue::is_empty(s2) {
+            None
+        } else {
+            Some(
+                #[hdl(sim)]
+                (
+                    Queue::pop(s1).expect("just checked"),
+                    Queue::pop(s2).expect("just checked"),
+                ),
+            )
+        }
+    }
+    #[hdl]
+    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V) {
+        #[hdl(sim)]
+        let (s1, s2) = this;
+        visitor.visit(s1);
+        visitor.visit(s2);
+    }
+}
+
+trait StagesVisitSimValueRef<C: PhantomConstCpuConfig> {
+    fn visit<S: Stage<C>>(&mut self, stage: &SimValue<S>);
+}
+
+trait Stage<C: PhantomConstCpuConfig>: Type + SimValueDefault + ResetSteps {
+    type InputStages: Stages<C>;
     type Inputs: Type;
-    type Output: Type;
+    type Output: Type + SimValueDefault;
+    type ToExternalPipeInputInterface: Type;
+    type FromExternalPipeOutputInterface: Type;
+    type FromExternalPipeOutputItem: Type;
     type MaxOutputsPerStep: Size;
+    type ExternalPipeIoWidth: Size;
     type InputQueueSize: Size;
     type OutputQueueSize: Size;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input;
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs;
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output;
-    fn max_outputs_per_step(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType;
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType;
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType;
-    fn stage_output_ty(
-        config: PhantomConst<CpuConfig>,
-    ) -> StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>> {
-        StageOutput[Self::output_ty(config)][Self::max_outputs_per_step(config)][config]
-    }
-    /// see [`StageOutput`] for docs on output
+    fn inputs_ty(config: C) -> Self::Inputs;
+    fn output_ty(config: C) -> Self::Output;
+    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface;
+    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface;
+    fn from_external_pipe_output_item_ty(config: C) -> Self::FromExternalPipeOutputItem;
+
+    fn max_outputs_per_step(config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType;
+    fn external_pipe_io_width(config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType;
+    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType;
+    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType;
+
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>>;
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>>;
+
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs>;
+
+    /// see [`StageRunOutput`] for docs on output
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>>;
+    ) -> SimValue<StageRunOutput<C, Self>>;
     /// changes state to match `cancel`
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>);
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>);
 }
 
 macro_rules! hdl_type_alias_with_generics {
     (
         #[without_generics = $WithoutGenerics:ident, $OneGeneric:ident]
         #[ty = $ty:expr]
-        $vis:vis type $Type:ident<$Arg:ident: $Trait:ident, $C:ident: PhantomConstGet<CpuConfig>> = $Target:ty;
+        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
     ) => {
-        $vis type $Type<$Arg, $C> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
+        $vis type $Type<$C, $Arg> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
 
         $vis struct $WithoutGenerics {}
 
         #[allow(non_upper_case_globals)]
         $vis const $Type: $WithoutGenerics = $WithoutGenerics {};
 
-        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-        $vis struct $OneGeneric<$Arg: $Trait>($Arg);
+        const _: () = {
+            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
+            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
 
-        impl<$Arg: $Trait> std::ops::Index<$Arg> for $WithoutGenerics {
-            type Output = $OneGeneric<$Arg>;
+            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
+                type Output = $OneGeneric<$C>;
 
-            fn index(&self, arg: $Arg) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(arg)))
+                fn index(&self, config: $C) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
+                }
             }
-        }
 
-        impl<$Arg: $Trait, $C: PhantomConstGet<CpuConfig>> std::ops::Index<$C> for $OneGeneric<$Arg> {
-            type Output = $Type<$Arg, $C>;
+            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
+                type Output = $Type<$C, $Arg>;
 
-            fn index(&self, config: $C) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($ty(self.0, config)))
+                fn index(&self, arg: $Arg) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($ty(self.0, arg)))
+                }
             }
-        }
+        };
     };
     (
         #[without_generics = $WithoutGenerics:ident, $OneGeneric:ident]
         #[size = $size:expr]
-        $vis:vis type $Type:ident<$Arg:ident: $Trait:ident, $C:ident: PhantomConstGet<CpuConfig>> = $Target:ty;
+        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
     ) => {
-        $vis type $Type<$Arg, $C> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
+        $vis type $Type<$C, $Arg> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
 
         $vis struct $WithoutGenerics {}
 
         #[allow(non_upper_case_globals)]
         $vis const $Type: $WithoutGenerics = $WithoutGenerics {};
 
-        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-        $vis struct $OneGeneric<$Arg: $Trait>($Arg);
+        const _: () = {
+            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
+            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
 
-        impl<$Arg: $Trait> std::ops::Index<$Arg> for $WithoutGenerics {
-            type Output = $OneGeneric<$Arg>;
+            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
+                type Output = $OneGeneric<$C>;
 
-            fn index(&self, arg: $Arg) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(arg)))
+                fn index(&self, config: $C) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
+                }
             }
-        }
 
-        impl<$Arg: $Trait, $C: PhantomConstGet<CpuConfig>> std::ops::Index<$C> for $OneGeneric<$Arg> {
-            type Output = <$Type<$Arg, $C> as Size>::SizeType;
+            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
+                type Output = <$Type<$C, $Arg> as Size>::SizeType;
 
-            fn index(&self, config: $C) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($size(self.0, config)))
+                fn index(&self, arg: $Arg) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($size(self.0, arg)))
+                }
             }
-        }
+        };
     };
 }
 
 hdl_type_alias_with_generics! {
-    #[without_generics = StageTraitInputWithoutGenerics, StageTraitInputWithStage]
-    #[ty = |_stage, config: C| T::input_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitInput<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Input;
+    #[without_generics = StageInputStagesOutputsWithoutGenerics, StageInputStagesOutputsWithStage]
+    #[ty = |config: C, _stage| <T as Stage<C>>::InputStages::outputs_ty(config)]
+    type StageInputStagesOutputs<C: PhantomConstCpuConfig, T: Stage<C>> = <<T as Stage<C>>::InputStages as Stages<C>>::Outputs;
 }
 
 hdl_type_alias_with_generics! {
-    #[without_generics = StageTraitInputsWithoutGenerics, StageTraitInputsWithStage]
-    #[ty = |_stage, config: C| T::inputs_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitInputs<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Inputs;
+    #[without_generics = StageInputsWithoutGenerics, StageInputsWithStage]
+    #[ty = |config: C, _stage| T::inputs_ty(config)]
+    type StageInputs<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::Inputs;
 }
 
 hdl_type_alias_with_generics! {
-    #[without_generics = StageTraitOutputWithoutGenerics, StageTraitOutputWithStage]
-    #[ty = |_stage, config: C| T::output_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitOutput<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Output;
+    #[without_generics = StageOutputWithoutGenerics, StageOutputWithStage]
+    #[ty = |config: C, _stage| T::output_ty(config)]
+    type StageOutput<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::Output;
+}
+
+hdl_type_alias_with_generics! {
+    #[without_generics = StageToExternalPipeInputInterfaceWithoutGenerics, StageToExternalPipeInputInterfaceWithStage]
+    #[ty = |config: C, _stage| T::to_external_pipe_input_interface_ty(config)]
+    type StageToExternalPipeInputInterface<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::ToExternalPipeInputInterface;
+}
+
+hdl_type_alias_with_generics! {
+    #[without_generics = StageFromExternalPipeOutputInterfaceWithoutGenerics, StageFromExternalPipeOutputInterfaceWithStage]
+    #[ty = |config: C, _stage| T::from_external_pipe_output_interface_ty(config)]
+    type StageFromExternalPipeOutputInterface<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::FromExternalPipeOutputInterface;
+}
+
+hdl_type_alias_with_generics! {
+    #[without_generics = StageFromExternalPipeOutputItemWithoutGenerics, StageFromExternalPipeOutputItemWithStage]
+    #[ty = |config: C, _stage| T::from_external_pipe_output_item_ty(config)]
+    type StageFromExternalPipeOutputItem<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::FromExternalPipeOutputItem;
 }
 
 hdl_type_alias_with_generics! {
     #[without_generics = StageMaxOutputsPerStepWithoutGenerics, StageMaxOutputsPerStepWithStage]
-    #[size = |_stage, config: C| T::max_outputs_per_step(PhantomConst::new_interned(config.get()))]
-    type StageMaxOutputsPerStep<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::MaxOutputsPerStep;
+    #[size = |config: C, _stage| T::max_outputs_per_step(config)]
+    type StageMaxOutputsPerStep<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::MaxOutputsPerStep;
 }
 
 hdl_type_alias_with_generics! {
     #[without_generics = StageInputQueueSizeWithoutGenerics, StageInputQueueSizeWithStage]
-    #[size = |_stage, config: C| T::input_queue_size(PhantomConst::new_interned(config.get()))]
-    type StageInputQueueSize<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::InputQueueSize;
+    #[size = |config: C, _stage| T::input_queue_size(config)]
+    type StageInputQueueSize<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::InputQueueSize;
+}
+
+hdl_type_alias_with_generics! {
+    #[without_generics = StageExternalPipeIoWidthWithoutGenerics, StageExternalPipeIoWidthWithStage]
+    #[size = |config: C, _stage| T::external_pipe_io_width(config)]
+    type StageExternalPipeIoWidth<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::ExternalPipeIoWidth;
 }
 
 hdl_type_alias_with_generics! {
     #[without_generics = StageOutputQueueSizeWithoutGenerics, StageOutputQueueSizeWithStage]
-    #[size = |_stage, config: C| T::output_queue_size(PhantomConst::new_interned(config.get()))]
-    type StageOutputQueueSize<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::OutputQueueSize;
+    #[size = |config: C, _stage| T::output_queue_size(config)]
+    type StageOutputQueueSize<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::OutputQueueSize;
 }
 
+#[hdl]
+type StageToExternalPipeInputInput<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> = ArrayVec<StageInputStagesOutputs<C, S>, StageExternalPipeIoWidth<C, S>>;
+
+#[hdl]
+type StageToExternalPipeInputCancel<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> = HdlOption<UIntInRangeInclusiveType<ConstUsize<1>, StageInputQueueSize<C, S>>>;
+
+#[hdl]
+type StageExternalPipeIoReady<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> = UIntInRangeInclusiveType<ConstUsize<0>, StageExternalPipeIoWidth<C, S>>;
+
+#[hdl]
+type StageFromExternalPipeOutputData<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> = ArrayVec<StageFromExternalPipeOutputItem<C, S>, StageExternalPipeIoWidth<C, S>>;
+
 #[hdl(no_static)]
 struct NextPcStageOutput<C: PhantomConstGet<CpuConfig>> {
     start_pc: UInt<64>,
@@ -361,7 +594,7 @@ struct NextPcStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for NextPcStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -386,7 +619,7 @@ impl SimValueDefault for NextPcStageOutput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct NextPcStageState<C: PhantomConstGet<CpuConfig>> {
+struct NextPcStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     call_stack: CallStack,
     branch_target_buffer: BranchTargetBuffer,
     next_pc: UInt<64>,
@@ -394,7 +627,7 @@ struct NextPcStageState<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for NextPcStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -417,7 +650,7 @@ impl SimValueDefault for NextPcStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for NextPcStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for NextPcStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -436,49 +669,85 @@ impl ResetSteps for NextPcStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for NextPcStageState<PhantomConst<CpuConfig>> {
-    type Input = ();
+impl<C: PhantomConstCpuConfig> Stage<C> for NextPcStageState<C> {
+    type InputStages = ();
     type Inputs = ();
-    type Output = NextPcStageOutput<PhantomConst<CpuConfig>>;
+    type Output = NextPcStageOutput<C>;
+    type ToExternalPipeInputInterface = ();
+    type FromExternalPipeOutputInterface = ();
+    type FromExternalPipeOutputItem = ();
     type MaxOutputsPerStep = ConstUsize<1>;
+    type ExternalPipeIoWidth = ConstUsize<1>;
     type InputQueueSize = ConstUsize<1>;
     type OutputQueueSize = ConstUsize<1>;
 
-    fn input_ty(_config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn inputs_ty(_config: C) -> Self::Inputs {
         ()
     }
 
-    fn inputs_ty(_config: PhantomConst<CpuConfig>) -> Self::Inputs {
-        ()
-    }
-
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         NextPcStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_item_ty(_config: C) -> Self::FromExternalPipeOutputItem {
+        ()
+    }
+
+    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn external_pipe_io_width(_config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
         ConstUsize
     }
 
+    fn output_queue_size(_config: C) -> <Self::OutputQueueSize as Size>::SizeType {
+        ConstUsize
+    }
+
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &cancel.next_pc
+    }
+
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &mut cancel.next_pc
+    }
+
+    #[hdl]
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs> {
+        #[hdl(sim)]
+        let () = input_stages_outputs;
+        #[hdl(sim)]
+        let () = from_external_pipe_output_item;
+        #[hdl(sim)]
+        ()
+    }
+
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         _inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         let config = state.config.ty();
         let start_call_stack = state.call_stack.clone();
         let fetch_block_id = state.next_fetch_block_id.as_int();
@@ -557,15 +826,17 @@ impl Stage for NextPcStageState<PhantomConst<CpuConfig>> {
             config,
         };
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
-            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
+        StageRunOutput::<_, _> {
+            outputs: StageRunOutput[config][this_ty]
+                .outputs
+                .new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self {
             call_stack,
@@ -645,7 +916,7 @@ struct BrPredStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for BrPredStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -659,7 +930,7 @@ impl SimValueDefault for BrPredStageOutput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct BrPredStageState<C: PhantomConstGet<CpuConfig>> {
+struct BrPredStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     branch_history: UInt<6>,
     branch_predictor: Array<BranchPredictionState, { BRANCH_PREDICTOR_SIZE }>,
     config: C,
@@ -670,7 +941,7 @@ fn step_branch_history(branch_history: &mut SimValue<UInt<6>>, taken: bool) {
         ((&**branch_history << 1) | taken.cast_to_static::<UInt<1>>()).cast_to_static::<UInt<6>>();
 }
 
-impl BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
     fn branch_predictor_index(this: &SimValue<Self>, branch_pc: u64) -> usize {
         let mut t = this.branch_history.cast_to_static::<UInt<64>>().as_int();
         t ^= t.rotate_left(5) & !branch_pc.rotate_right(3);
@@ -684,7 +955,7 @@ impl BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl SimValueDefault for BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -705,7 +976,7 @@ impl SimValueDefault for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for BrPredStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -719,49 +990,82 @@ impl ResetSteps for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
-    type Input = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Output = BrPredStageOutput<PhantomConst<CpuConfig>>;
+impl<C: PhantomConstCpuConfig> Stage<C> for BrPredStageState<C> {
+    type InputStages = NextPcStageState<C>;
+    type Inputs = NextPcStageOutput<C>;
+    type Output = BrPredStageOutput<C>;
+    type ToExternalPipeInputInterface = ();
+    type FromExternalPipeOutputInterface = ();
+    type FromExternalPipeOutputItem = ();
     type MaxOutputsPerStep = ConstUsize<1>;
+    type ExternalPipeIoWidth = ConstUsize<1>;
     type InputQueueSize = ConstUsize<1>;
-    type OutputQueueSize = CpuConfigMaxFetchesInFlight<PhantomConst<CpuConfig>>;
+    type OutputQueueSize = CpuConfigMaxFetchesInFlight<C>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn inputs_ty(config: C) -> Self::Inputs {
         NextPcStageOutput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
-        NextPcStageOutput[config]
-    }
-
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         BrPredStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_item_ty(_config: C) -> Self::FromExternalPipeOutputItem {
+        ()
+    }
+
+    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn external_pipe_io_width(_config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
+        ConstUsize
+    }
+
+    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType {
         CpuConfigMaxFetchesInFlight[config]
     }
 
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &cancel.br_pred
+    }
+
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &mut cancel.br_pred
+    }
+
+    #[hdl]
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs> {
+        #[hdl(sim)]
+        let () = from_external_pipe_output_item;
+        input_stages_outputs.clone()
+    }
+
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         let config = state.config.ty();
         #[hdl(sim)]
         let NextPcStageOutput::<_> {
@@ -806,9 +1110,9 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
                     let btb_entry_index = &btb_entry.0;
                     let mut btb_entry = btb_entry.1.clone();
                     btb_entry.addr_kind = opposite_addr_kind;
-                    let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
+                    let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
                     let retval = #[hdl(sim)]
-                    StageOutput::<_, _, _> {
+                    StageRunOutput::<_, _> {
                         outputs: outputs.sim_value_default(),
                         cancel: #[hdl(sim)]
                         cancel.HdlSome(
@@ -839,15 +1143,17 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
             config,
         };
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
-            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
+        StageRunOutput::<_, _> {
+            outputs: StageRunOutput[config][this_ty]
+                .outputs
+                .new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Cancel::<_> {
             call_stack: _,
@@ -861,7 +1167,7 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
     #[hdl]
     fn train_branch_predictor(
         this: &mut SimValue<Self>,
@@ -884,11 +1190,11 @@ impl BrPredStageState<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig>> {
+struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
-impl SimValueDefault for FetchDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -898,7 +1204,7 @@ impl SimValueDefault for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for FetchDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for FetchDecodeStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -913,7 +1219,7 @@ struct FetchDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     decode_output: DecodeToPostDecodeInterfaceInner<C>,
 }
 
-impl SimValueDefault for FetchDecodeStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -928,55 +1234,90 @@ impl SimValueDefault for FetchDecodeStageOutput<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for FetchDecodeStageState<PhantomConst<CpuConfig>> {
-    type Input = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type Output = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
+impl<C: PhantomConstCpuConfig> Stage<C> for FetchDecodeStageState<C> {
+    type InputStages = NextPcStageState<C>;
+    type Inputs = FetchDecodeStageOutput<C>;
+    type Output = FetchDecodeStageOutput<C>;
+    type ToExternalPipeInputInterface = NextPcToFetchInterface<C>;
+    type FromExternalPipeOutputInterface = DecodeToPostDecodeInterface<C>;
+    type FromExternalPipeOutputItem = DecodeToPostDecodeInterfaceInner<C>;
     type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = CpuConfigMaxFetchesInFlight<PhantomConst<CpuConfig>>;
+    type ExternalPipeIoWidth = ConstUsize<1>;
+    type InputQueueSize = CpuConfigMaxFetchesInFlight<C>;
     type OutputQueueSize = ConstUsize<1>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
-        NextPcStageOutput[config]
-    }
-
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         FetchDecodeStageOutput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         FetchDecodeStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface {
+        NextPcToFetchInterface[config]
+    }
+
+    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface {
+        DecodeToPostDecodeInterface[config]
+    }
+
+    fn from_external_pipe_output_item_ty(config: C) -> Self::FromExternalPipeOutputItem {
+        DecodeToPostDecodeInterfaceInner[config]
+    }
+
+    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn external_pipe_io_width(_config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType {
+        ConstUsize
+    }
+
+    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
         CpuConfigMaxFetchesInFlight[config]
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    fn output_queue_size(_config: C) -> <Self::OutputQueueSize as Size>::SizeType {
         ConstUsize
     }
 
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &cancel.fetch_decode
+    }
+
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &mut cancel.fetch_decode
+    }
+
+    #[hdl]
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs> {
+        #[hdl(sim)]
+        FetchDecodeStageOutput::<_> {
+            next_pc_stage_output: input_stages_outputs,
+            decode_output: from_external_pipe_output_item,
+        }
+    }
+
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
-        let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
+        let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
+        StageRunOutput::<_, _> {
             outputs: outputs.new_full_sim([inputs]),
             cancel: #[hdl(sim)]
             cancel.HdlNone(),
@@ -984,14 +1325,14 @@ impl Stage for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
 }
 
 #[hdl(no_static)]
-struct PostDecodeStageState<C: PhantomConstGet<CpuConfig>> {
+struct PostDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
@@ -1001,7 +1342,7 @@ struct PostDecodeStageInput<C: PhantomConstGet<CpuConfig>> {
     br_pred_stage_output: BrPredStageOutput<C>,
 }
 
-impl SimValueDefault for PostDecodeStageInput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageInput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1023,7 +1364,7 @@ struct PostDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for PostDecodeStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1041,7 +1382,7 @@ impl SimValueDefault for PostDecodeStageOutput<PhantomConst<CpuConfig>> {
     }
 }
 
-impl SimValueDefault for PostDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1051,7 +1392,7 @@ impl SimValueDefault for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for PostDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for PostDecodeStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1060,49 +1401,88 @@ impl ResetSteps for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
-    type Input = PostDecodeStageInput<PhantomConst<CpuConfig>>;
-    type Inputs = PostDecodeStageInput<PhantomConst<CpuConfig>>;
-    type Output = PostDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type MaxOutputsPerStep = CpuConfigFetchWidth<PhantomConst<CpuConfig>>;
+impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
+    type InputStages = (FetchDecodeStageState<C>, BrPredStageState<C>);
+    type Inputs = PostDecodeStageInput<C>;
+    type Output = PostDecodeStageOutput<C>;
+    type ToExternalPipeInputInterface = ();
+    type FromExternalPipeOutputInterface = ();
+    type FromExternalPipeOutputItem = ();
+    type MaxOutputsPerStep = CpuConfigFetchWidth<C>;
+    type ExternalPipeIoWidth = ConstUsize<1>;
     type InputQueueSize = ConstUsize<1>;
-    type OutputQueueSize = TwiceCpuConfigFetchWidth<PhantomConst<CpuConfig>>;
+    type OutputQueueSize = TwiceCpuConfigFetchWidth<C>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn inputs_ty(config: C) -> Self::Inputs {
         PostDecodeStageInput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
-        PostDecodeStageInput[config]
-    }
-
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         PostDecodeStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
+        ()
+    }
+
+    fn from_external_pipe_output_item_ty(_config: C) -> Self::FromExternalPipeOutputItem {
+        ()
+    }
+
+    fn max_outputs_per_step(config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
         CpuConfigFetchWidth[config]
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn external_pipe_io_width(_config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
+        ConstUsize
+    }
+
+    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType {
         TwiceCpuConfigFetchWidth[config]
     }
 
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &cancel.post_decode
+    }
+
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &mut cancel.post_decode
+    }
+
+    #[hdl]
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs> {
+        #[hdl(sim)]
+        let (fetch_decode_stage_output, br_pred_stage_output) = input_stages_outputs;
+        #[hdl(sim)]
+        let () = from_external_pipe_output_item;
+        #[hdl(sim)]
+        PostDecodeStageInput::<_> {
+            fetch_decode_stage_output,
+            br_pred_stage_output,
+        }
+    }
+
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
@@ -1140,10 +1520,10 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             -- either the decoded instructions or a WipDecodedInsnKind::Interrupt",
         );
         let insns = ArrayVec::elements_sim_ref(&insns);
-        let StageOutput {
+        let StageRunOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = Self::stage_output_ty(config);
+        } = StageRunOutput[config][this_ty];
         assert_eq!(outputs_ty.capacity(), decode_output.insns.ty().capacity());
         let mut outputs = outputs_ty.sim_value_default();
         let mut add_output_insn = |insn: &SimValue<WipDecodedInsn>,
@@ -1192,7 +1572,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             let mut call_stack = start_call_stack.clone();
             CallStack::push(&mut call_stack, start_pc);
             let retval = #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1389,7 +1769,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
         };
         if *new_btb_entry.cmp_ne(predicted_btb_entry) {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.sim_value_default(),
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1406,7 +1786,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             }
         } else {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlNone(),
@@ -1415,7 +1795,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
@@ -1427,7 +1807,7 @@ struct ExecuteRetireStageInput<C: PhantomConstGet<CpuConfig>> {
     retire_interface_per_insn: RetireToNextPcInterfacePerInsn<C>,
 }
 
-impl SimValueDefault for ExecuteRetireStageInput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageInput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -1443,7 +1823,7 @@ impl SimValueDefault for ExecuteRetireStageInput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct ExecuteRetireStageState<C: PhantomConstGet<CpuConfig>> {
+struct ExecuteRetireStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
@@ -1453,7 +1833,23 @@ struct ExecuteRetireStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageOutput<C> {
+    #[hdl]
+    fn sim_value_default(self) -> SimValue<Self> {
+        let Self {
+            train_branch_predictor,
+            config,
+        } = self;
+        #[hdl(sim)]
+        Self {
+            train_branch_predictor: #[hdl(sim)]
+            train_branch_predictor.HdlNone(),
+            config,
+        }
+    }
+}
+
+impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { config } = self;
@@ -1462,7 +1858,7 @@ impl SimValueDefault for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for ExecuteRetireStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1471,49 +1867,84 @@ impl ResetSteps for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
-    type Input = PostDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = ExecuteRetireStageInput<PhantomConst<CpuConfig>>;
-    type Output = ExecuteRetireStageOutput<PhantomConst<CpuConfig>>;
+impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
+    type InputStages = PostDecodeStageState<C>;
+    type Inputs = ExecuteRetireStageInput<C>;
+    type Output = ExecuteRetireStageOutput<C>;
+    type ToExternalPipeInputInterface = PostDecodeOutputInterface<C>;
+    type FromExternalPipeOutputInterface = RetireToNextPcInterface<C>;
+    type FromExternalPipeOutputItem = RetireToNextPcInterfacePerInsn<C>;
     type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = CpuConfigRobSize<PhantomConst<CpuConfig>>;
-    type OutputQueueSize = ConstUsize<1>;
+    type ExternalPipeIoWidth = CpuConfigFetchWidth<C>;
+    type InputQueueSize = CpuConfigRobSize<C>;
+    type OutputQueueSize = CpuConfigFetchWidth<C>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
-        PostDecodeStageOutput[config]
-    }
-
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         ExecuteRetireStageInput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         ExecuteRetireStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface {
+        PostDecodeOutputInterface[config]
+    }
+
+    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface {
+        RetireToNextPcInterface[config]
+    }
+
+    fn from_external_pipe_output_item_ty(config: C) -> Self::FromExternalPipeOutputItem {
+        RetireToNextPcInterfacePerInsn[config]
+    }
+
+    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn external_pipe_io_width(config: C) -> <Self::ExternalPipeIoWidth as Size>::SizeType {
+        CpuConfigFetchWidth[config]
+    }
+
+    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
         CpuConfigRobSize[config]
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
-        ConstUsize
+    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType {
+        CpuConfigFetchWidth[config]
+    }
+
+    fn cancel_in_progress_for_stage_ref(
+        cancel: &SimValue<CancelInProgress<C>>,
+    ) -> &SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &cancel.execute_retire
+    }
+
+    fn cancel_in_progress_for_stage_mut(
+        cancel: &mut SimValue<CancelInProgress<C>>,
+    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
+        &mut cancel.execute_retire
+    }
+
+    #[hdl]
+    fn make_inputs(
+        input_stages_outputs: &SimValue<StageInputStagesOutputs<C, Self>>,
+        from_external_pipe_output_item: &SimValue<Self::FromExternalPipeOutputItem>,
+    ) -> SimValue<Self::Inputs> {
+        #[hdl(sim)]
+        ExecuteRetireStageInput::<_> {
+            post_decode_stage_output: input_stages_outputs,
+            retire_interface_per_insn: from_external_pipe_output_item,
+        }
     }
 
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
@@ -1541,10 +1972,10 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
             config: _,
         } = post_decode_stage_output;
         assert_eq!(*id, insn.id, "instruction queuing out of sync");
-        let StageOutput {
+        let StageRunOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = Self::stage_output_ty(config);
+        } = StageRunOutput[config][this_ty];
         let mut branch_history = start_branch_history.clone();
         let train_branch_predictor = #[hdl(sim)]
         if let HdlSome(taken) = cond_br_taken {
@@ -1671,7 +2102,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
                 CallStackOp::Unknown => unreachable!(),
             }
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.new_sim(
                     #[hdl(sim)]
                     ExecuteRetireStageOutput::<_> {
@@ -1694,7 +2125,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
             }
         } else {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.new_full_sim([
                     #[hdl(sim)]
                     ExecuteRetireStageOutput::<_> {
@@ -1709,7 +2140,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
@@ -1794,6 +2225,26 @@ impl<T: SimOnlyValueTrait> SimValueDefault for SimOnly<T> {
     }
 }
 
+impl<T: ?Sized + fayalite::phantom_const::PhantomConstValue> SimValueDefault for PhantomConst<T> {
+    fn sim_value_default(self) -> SimValue<Self> {
+        self.to_sim_value()
+    }
+}
+
+impl SimValueDefault for () {
+    fn sim_value_default(self) -> SimValue<Self> {
+        self.to_sim_value()
+    }
+}
+
+impl<T1: SimValueDefault, T2: SimValueDefault> SimValueDefault for (T1, T2) {
+    #[hdl]
+    fn sim_value_default(self) -> SimValue<Self> {
+        #[hdl(sim)]
+        (self.0.sim_value_default(), self.1.sim_value_default())
+    }
+}
+
 impl<T: SimValueDefault, N: Size> SimValueDefault for ArrayVec<T, N> {
     fn sim_value_default(self) -> SimValue<Self> {
         self.new_sim(self.element().sim_value_default())
@@ -2231,6 +2682,8 @@ struct Queue<T, Capacity: Size> {
     head: UIntInRangeType<ConstUsize<0>, Capacity>,
     /// exclusive
     tail: UIntInRangeType<ConstUsize<0>, Capacity>,
+    /// used to disambiguate between a full and an empty queue
+    eq_head_tail_means_full: Bool,
 }
 
 impl<T: Type, Capacity: Size> Queue<T, Capacity> {
@@ -2241,21 +2694,27 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
         assert_ne!(self.capacity(), 0);
         (pos + 1) % self.capacity()
     }
+    fn nth_pos_after(self, pos: usize, nth: usize) -> usize {
+        assert_ne!(self.capacity(), 0);
+        (pos + nth) % self.capacity()
+    }
     fn prev_pos(self, pos: usize) -> usize {
         assert_ne!(self.capacity(), 0);
         (pos + self.capacity() - 1) % self.capacity()
     }
     fn is_empty(this: &SimValue<Self>) -> bool {
-        this.head == this.tail
+        this.head == this.tail && !*this.eq_head_tail_means_full
     }
     fn is_full(this: &SimValue<Self>) -> bool {
-        let head = *this.head;
-        let tail = *this.tail;
-        this.ty().next_pos(head) == tail
+        this.head == this.tail && *this.eq_head_tail_means_full
     }
     fn len(this: &SimValue<Self>) -> usize {
         let capacity = this.ty().capacity();
-        (*this.tail + capacity - *this.head) % capacity
+        if Self::is_full(this) {
+            capacity
+        } else {
+            (*this.tail + capacity - *this.head) % capacity
+        }
     }
     fn space_left(this: &SimValue<Self>) -> usize {
         this.ty().capacity() - Self::len(this)
@@ -2263,6 +2722,7 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
     fn clear(this: &mut SimValue<Self>) {
         *this.head = 0;
         *this.tail = 0;
+        *this.eq_head_tail_means_full = false;
     }
     fn try_push(this: &mut SimValue<Self>, value: impl ToSimValueWithType<T>) -> Result<(), ()> {
         if Self::is_full(this) {
@@ -2271,6 +2731,7 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let head = *this.head;
             let head = this.ty().next_pos(head);
             *this.head = head;
+            *this.eq_head_tail_means_full = true;
             let data = &mut this.data[head];
             *data = value.to_sim_value_with_type(data.ty());
             Ok(())
@@ -2284,6 +2745,7 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let data = this.data[head].clone();
             let head = this.ty().prev_pos(head);
             *this.head = head;
+            *this.eq_head_tail_means_full = false;
             Some(data)
         }
     }
@@ -2294,6 +2756,11 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             Some(this.data[*this.tail].clone())
         }
     }
+    fn peek_iter(
+        this: &SimValue<Self>,
+    ) -> impl Clone + DoubleEndedIterator<Item = SimValue<T>> + ExactSizeIterator {
+        (0..Self::len(this)).map(|nth| this.data[this.ty().nth_pos_after(*this.tail, nth)].clone())
+    }
     fn pop(this: &mut SimValue<Self>) -> Option<SimValue<T>> {
         if Self::is_empty(this) {
             None
@@ -2301,6 +2768,7 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let tail = *this.tail;
             let data = this.data[tail].clone();
             *this.tail = this.ty().next_pos(tail);
+            *this.eq_head_tail_means_full = false;
             Some(data)
         }
     }
@@ -2309,7 +2777,12 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
 impl<T: SimValueDefault, Capacity: Size> SimValueDefault for Queue<T, Capacity> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
-        let Self { data, head, tail } = self;
+        let Self {
+            data,
+            head,
+            tail,
+            eq_head_tail_means_full: _,
+        } = self;
         #[hdl(sim)]
         Queue::<T, Capacity> {
             data: repeat(
@@ -2318,6 +2791,7 @@ impl<T: SimValueDefault, Capacity: Size> SimValueDefault for Queue<T, Capacity>
             ),
             head: 0usize.to_sim_value_with_type(head),
             tail: 0usize.to_sim_value_with_type(tail),
+            eq_head_tail_means_full: false,
         }
     }
 }
@@ -2326,55 +2800,268 @@ impl<T: SimValueDefault, Capacity: Size> ResetSteps for Queue<T, Capacity> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
-        let Queue::<T, Capacity> { data, head, tail } = this;
+        let Queue::<T, Capacity> {
+            data,
+            head,
+            tail,
+            eq_head_tail_means_full,
+        } = this;
         **head = 0;
         **tail = 0;
+        **eq_head_tail_means_full = false;
         ResetSteps::reset_step(data, step)
     }
 }
 
 #[hdl(no_static)]
-struct StageWithQueues<S: Type + Stage, C: PhantomConstGet<CpuConfig>> {
-    state: S,
-    input_queue: Queue<StageTraitInput<S, C>, StageInputQueueSize<S, C>>,
-    output_queue: Queue<StageTraitOutput<S, C>, StageOutputQueueSize<S, C>>,
-}
-
-impl<S: Stage> StageWithQueues<S, PhantomConst<CpuConfig>> {
-    FIXME
+struct CancelInProgressForStageWithQueues<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> {
+    cancel_state: Bool,
+    input_queue_to_cancel: UIntInRangeInclusiveType<ConstUsize<0>, StageInputQueueSize<C, S>>,
+    output_queue_to_cancel: UIntInRangeInclusiveType<ConstUsize<0>, StageOutputQueueSize<C, S>>,
 }
 
 #[hdl(no_static)]
-struct CancelInProgress<C: PhantomConstGet<CpuConfig>> {
-    cancel: Cancel<C>,
-    br_pred_stage_inputs_to_cancel: UIntInRangeInclusive<0, 32>,
-    br_pred_stage_cancel: Bool,
-    fetch_decode_stage_inputs_to_cancel:
-        UIntInRangeInclusiveType<ConstUsize<0>, CpuConfigMaxFetchesInFlight<C>>,
-    fetch_decode_stage_cancel: Bool,
-    post_decode_stage_inputs_to_cancel: UIntInRangeInclusive<0, 1>,
-    post_decode_stage_cancel: Bool,
-    post_decode_stage_outputs_to_cancel:
-        UIntInRangeInclusiveType<ConstUsize<0>, TwiceCpuConfigFetchWidth<C>>,
-    rename_dispatch_execute_stage_inputs_to_cancel: UIntInRangeInclusive<0, 256>,
-    rename_dispatch_execute_stage_cancel: Bool,
-    retire_stage_inputs_to_cancel: UIntInRangeInclusive<0, 1>,
-    retire_stage_cancel: Bool,
+struct StageWithQueues<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig, S: Type + Stage<C>> {
+    input_queue: Queue<StageInputStagesOutputs<C, S>, StageInputQueueSize<C, S>>,
+    state: S,
+    output_queue: Queue<StageOutput<C, S>, StageOutputQueueSize<C, S>>,
     config: C,
 }
 
-impl CancelInProgress<PhantomConst<CpuConfig>> {
+#[hdl(no_static)]
+struct StageWithQueuesInputs<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> {
+    to_external_pipe_input_input_ready: StageExternalPipeIoReady<C, S>,
+    to_external_pipe_input_cancel_ready: Bool,
+    from_external_pipe_output_data: StageFromExternalPipeOutputData<C, S>,
+}
+
+#[hdl(no_static)]
+struct StageWithQueuesOutputs<
+    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
+    S: Type + Stage<C>,
+> {
+    to_external_pipe_input_input: StageToExternalPipeInputInput<C, S>,
+    to_external_pipe_input_cancel: StageToExternalPipeInputCancel<C, S>,
+    from_external_pipe_output_ready: StageExternalPipeIoReady<C, S>,
+}
+
+enum CancelResult {
+    Done,
+    InProgress,
+}
+
+impl<C: PhantomConstCpuConfig, S: Stage<C>> StageWithQueues<C, S> {
+    #[hdl]
+    fn outputs(
+        this: &SimValue<Self>,
+        cancel: Option<&SimValue<CancelInProgress<C>>>,
+        input_stages_output_queues: <S::InputStages as Stages<C>>::SimValueOutputQueueRefs<'_>,
+    ) -> SimValue<StageWithQueuesOutputs<C, S>> {
+        #[hdl(sim)]
+        let Self {
+            input_queue,
+            state,
+            output_queue,
+            config,
+        } = this;
+        let config = config.ty();
+        let state_ty = state.ty();
+        let ty = StageWithQueuesOutputs[config][state_ty];
+        let cancel_ty = ty.to_external_pipe_input_cancel;
+        if let Some(cancel) = cancel {
+            let input_queue_to_cancel =
+                *S::cancel_in_progress_for_stage_ref(cancel).input_queue_to_cancel;
+            let to_external_pipe_input_cancel = if input_queue_to_cancel > 0 {
+                #[hdl(sim)]
+                cancel_ty.HdlSome(input_queue_to_cancel.to_sim_value_with_type(cancel_ty.HdlSome))
+            } else {
+                #[hdl(sim)]
+                cancel_ty.HdlNone()
+            };
+            #[hdl(sim)]
+            StageWithQueuesOutputs::<_, _> {
+                to_external_pipe_input_input: ty.to_external_pipe_input_input.sim_value_default(),
+                to_external_pipe_input_cancel,
+                from_external_pipe_output_ready: 0usize
+                    .to_sim_value_with_type(ty.from_external_pipe_output_ready),
+            }
+        } else {
+            let mut to_external_pipe_input_input =
+                ty.to_external_pipe_input_input.sim_value_default();
+            for input in S::InputStages::peek_output_queues(
+                input_stages_output_queues,
+                Queue::space_left(&this.input_queue),
+            ) {
+                let Ok(_) = ArrayVec::try_push_sim(&mut to_external_pipe_input_input, input) else {
+                    break;
+                };
+            }
+            #[hdl(sim)]
+            StageWithQueuesOutputs::<_, _> {
+                to_external_pipe_input_input,
+                to_external_pipe_input_cancel: #[hdl(sim)]
+                cancel_ty.HdlNone(),
+                from_external_pipe_output_ready: Queue::space_left(output_queue)
+                    .min(Size::as_usize(S::external_pipe_io_width(config)))
+                    .to_sim_value_with_type(ty.from_external_pipe_output_ready),
+            }
+        }
+    }
+    #[hdl]
+    fn cancel(
+        this: &mut SimValue<Self>,
+        cancel: &mut SimValue<CancelInProgress<C>>,
+        inputs: &SimValue<StageWithQueuesInputs<C, S>>,
+        last_outputs: &SimValue<StageWithQueuesOutputs<C, S>>,
+        input_stages_output_queues: <S::InputStages as Stages<C>>::SimValueOutputQueueMuts<'_>,
+    ) -> CancelResult {
+        #[hdl(sim)]
+        let Self {
+            input_queue,
+            state,
+            output_queue,
+            config,
+        } = this;
+        let config = config.ty();
+        let state_ty = state.ty();
+        #[hdl(sim)]
+        let CancelInProgressForStageWithQueues::<_, _> {
+            cancel_state,
+            input_queue_to_cancel,
+            output_queue_to_cancel,
+        } = S::cancel_in_progress_for_stage_mut(cancel);
+        #[hdl(sim)]
+        let StageWithQueuesInputs::<_, _> {
+            to_external_pipe_input_input_ready: _,
+            to_external_pipe_input_cancel_ready,
+            from_external_pipe_output_data: _,
+        } = inputs;
+        #[hdl(sim)]
+        let StageWithQueuesOutputs::<_, _> {
+            to_external_pipe_input_input,
+            to_external_pipe_input_cancel,
+            from_external_pipe_output_ready,
+        } = last_outputs;
+        assert_eq!(**ArrayVec::len_sim(to_external_pipe_input_input), 0);
+        #[hdl(sim)]
+        if let HdlNone = to_external_pipe_input_cancel {
+            unreachable!();
+        }
+        assert_eq!(**from_external_pipe_output_ready, 0);
+        if !**to_external_pipe_input_cancel_ready {
+            return CancelResult::InProgress;
+        }
+        for _ in 0..std::mem::replace(input_queue_to_cancel, 0) {
+            let Some(_) = Queue::undo_push(input_queue) else {
+                unreachable!();
+            };
+        }
+        for _ in 0..std::mem::replace(output_queue_to_cancel, 0) {
+            let Some(_) = Queue::undo_push(output_queue) else {
+                unreachable!();
+            };
+        }
+        if std::mem::replace(cancel_state, false) {
+            S::cancel(state, &cancel.cancel);
+        }
+        CancelResult::Done
+    }
+    #[hdl]
+    fn make_cancel_all(
+        this: &SimValue<Self>,
+    ) -> SimValue<CancelInProgressForStageWithQueues<C, S>> {
+        #[hdl(sim)]
+        let Self {
+            input_queue,
+            state,
+            output_queue,
+            config,
+        } = this;
+        let CancelInProgressForStageWithQueues {
+            cancel_state: _,
+            input_queue_to_cancel,
+            output_queue_to_cancel,
+        } = CancelInProgressForStageWithQueues[config.ty()][state.ty()];
+        #[hdl(sim)]
+        CancelInProgressForStageWithQueues::<_, _> {
+            cancel_state: true,
+            input_queue_to_cancel: Queue::len(input_queue)
+                .to_sim_value_with_type(input_queue_to_cancel),
+            output_queue_to_cancel: Queue::len(output_queue)
+                .to_sim_value_with_type(output_queue_to_cancel),
+        }
+    }
+    #[hdl]
+    fn run(
+        this: &mut SimValue<Self>,
+        inputs: &SimValue<StageWithQueuesInputs<C, S>>,
+        last_outputs: &SimValue<StageWithQueuesOutputs<C, S>>,
+        input_stages_output_queues: <S::InputStages as Stages<C>>::SimValueOutputQueueMuts<'_>,
+    ) -> Result<
+        (),
+        (
+            SimValue<Cancel<C>>,
+            SimValue<CancelInProgressForStageWithQueues<C, S>>,
+        ),
+    > {
+        #[hdl(sim)]
+        let Self {
+            input_queue,
+            state,
+            output_queue,
+            config,
+        } = this;
+        let config = config.ty();
+        let state_ty = state.ty();
+        #[hdl(sim)]
+        let StageWithQueuesInputs::<_, _> {
+            to_external_pipe_input_input_ready,
+            to_external_pipe_input_cancel_ready: _,
+            from_external_pipe_output_data,
+        } = inputs;
+        #[hdl(sim)]
+        let StageWithQueuesOutputs::<_, _> {
+            to_external_pipe_input_input,
+            to_external_pipe_input_cancel,
+            from_external_pipe_output_ready,
+        } = last_outputs;
+        #[hdl(sim)]
+        if let HdlSome(_) = to_external_pipe_input_cancel {
+            unreachable!();
+        }
+        let to_external_pipe_input_input_len = **ArrayVec::len_sim(to_external_pipe_input_input);
+        for _ in 0..to_external_pipe_input_input_len.min(**to_external_pipe_input_input_ready) {
+            let Some(v) = S::InputStages::pop_output_queues(input_stages_output_queues) else {
+                unreachable!();
+            };
+        }
+        todo!()
+    }
+}
+
+#[hdl(no_static)]
+struct CancelInProgress<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+    cancel: Cancel<C>,
+    next_pc: CancelInProgressForStageWithQueues<C, NextPcStageState<C>>,
+    br_pred: CancelInProgressForStageWithQueues<C, BrPredStageState<C>>,
+    fetch_decode: CancelInProgressForStageWithQueues<C, FetchDecodeStageState<C>>,
+    post_decode: CancelInProgressForStageWithQueues<C, PostDecodeStageState<C>>,
+    execute_retire: CancelInProgressForStageWithQueues<C, ExecuteRetireStageState<C>>,
+    config: C,
+}
+
+impl<C: PhantomConstCpuConfig> CancelInProgress<C> {
     #[hdl]
     fn to_fetch_cancel_data(
         this: &SimValue<Self>,
-    ) -> SimValue<
-        HdlOption<
-            UIntInRangeInclusiveType<
-                ConstUsize<1>,
-                CpuConfigMaxFetchesInFlight<PhantomConst<CpuConfig>>,
-            >,
-        >,
-    > {
+    ) -> SimValue<HdlOption<UIntInRangeInclusiveType<ConstUsize<1>, CpuConfigMaxFetchesInFlight<C>>>>
+    {
         let NextPcStateOutputs {
             to_fetch_cancel_data,
             ..
@@ -2406,7 +3093,7 @@ pub struct StatesAndQueues<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for StatesAndQueues<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2445,7 +3132,7 @@ impl SimValueDefault for StatesAndQueues<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for StatesAndQueues<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2493,12 +3180,12 @@ impl ResetSteps for StatesAndQueues<PhantomConst<CpuConfig>> {
     }
 }
 
-impl StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> StatesAndQueues<C> {
     #[hdl]
     fn step_no_cancel(
         this: &mut SimValue<Self>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
-    ) -> SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>> {
+        inputs: SimValue<NextPcStateStepInputs<C>>,
+    ) -> SimValue<HdlOption<CancelInProgress<C>>> {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
             to_fetch_fetch_triggered,
@@ -2532,7 +3219,7 @@ impl StatesAndQueues<PhantomConst<CpuConfig>> {
             todo!()
         }
         #[hdl(sim)]
-        let StageOutput::<_, _, _> { outputs, cancel } =
+        let StageRunOutput::<_, _> { outputs, cancel } =
             Stage::run(next_pc_stage_state, &().to_sim_value());
 
         retval
@@ -2540,8 +3227,8 @@ impl StatesAndQueues<PhantomConst<CpuConfig>> {
     #[hdl]
     fn step_cancel(
         this: &mut SimValue<Self>,
-        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
+        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<C>>>,
+        inputs: SimValue<NextPcStateStepInputs<C>>,
     ) {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
@@ -2649,7 +3336,7 @@ pub struct NextPcState<C: PhantomConstGet<CpuConfig>> {
     cancel: HdlOption<CancelInProgress<C>>,
 }
 
-impl SimValueDefault for NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2664,7 +3351,7 @@ impl SimValueDefault for NextPcState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for NextPcState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2698,9 +3385,9 @@ struct NextPcStateStepInputs<C: PhantomConstGet<CpuConfig>> {
     from_retire_inner_triggered: HdlOption<RetireToNextPcInterfaceInner<C>>,
 }
 
-impl NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> NextPcState<C> {
     #[hdl]
-    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<PhantomConst<CpuConfig>>> {
+    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<C>> {
         #[hdl(sim)]
         let Self {
             states_and_queues,
@@ -2785,10 +3472,7 @@ impl NextPcState<PhantomConst<CpuConfig>> {
         }
     }
     #[hdl]
-    fn step(
-        this: &mut SimValue<Self>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
-    ) {
+    fn step(this: &mut SimValue<Self>, inputs: SimValue<NextPcStateStepInputs<C>>) {
         #[hdl(sim)]
         let Self {
             states_and_queues,