diff --git a/crates/minikalman/benches/gravity.rs b/crates/minikalman/benches/gravity.rs
index 3643332..4a50162 100644
--- a/crates/minikalman/benches/gravity.rs
+++ b/crates/minikalman/benches/gravity.rs
@@ -26,6 +26,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     let mut gravity_x = BufferBuilder::state_vector_x::<NUM_STATES>().new();
     let mut gravity_A = BufferBuilder::system_matrix_A::<NUM_STATES>().new();
     let mut gravity_P = BufferBuilder::estimate_covariance_P::<NUM_STATES>().new();
+    let mut gravity_Q = BufferBuilder::direct_process_noise_covariance_Q::<NUM_STATES>().new();
 
     // Control buffers.
     // let mut gravity_u = BufferBuilder::control_vector_u::<NUM_CONTROLS>().new();
@@ -56,6 +57,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
@@ -100,6 +102,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
@@ -138,6 +141,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
diff --git a/crates/minikalman/benches/gravity_fixed.rs b/crates/minikalman/benches/gravity_fixed.rs
index 4c3d946..fe32e54 100644
--- a/crates/minikalman/benches/gravity_fixed.rs
+++ b/crates/minikalman/benches/gravity_fixed.rs
@@ -65,6 +65,7 @@ fn criterion_benchmark(c: &mut Criterion) {
     let mut gravity_x = BufferBuilder::state_vector_x::<NUM_STATES>().new();
     let mut gravity_A = BufferBuilder::system_matrix_A::<NUM_STATES>().new();
     let mut gravity_P = BufferBuilder::estimate_covariance_P::<NUM_STATES>().new();
+    let mut gravity_Q = BufferBuilder::direct_process_noise_covariance_Q::<NUM_STATES>().new();
 
     // Observation buffers.
     let mut gravity_z = BufferBuilder::measurement_vector_z::<NUM_OBSERVATIONS>().new();
@@ -89,6 +90,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
@@ -133,6 +135,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
@@ -171,6 +174,7 @@ fn criterion_benchmark(c: &mut Criterion) {
             StateTransitionMatrixMutBuffer::from(gravity_A.as_mut_slice()),
             StateVectorBuffer::from(gravity_x.as_mut_slice()),
             EstimateCovarianceMatrixBuffer::from(gravity_P.as_mut_slice()),
+            DirectProcessNoiseCovarianceMatrixBuffer::from(gravity_Q.as_mut_slice()),
             PredictedStateEstimateVectorBuffer::from(gravity_temp_x.as_mut_slice()),
             TemporaryStateMatrixBuffer::from(gravity_temp_P.as_mut_slice()),
         );
diff --git a/crates/minikalman/examples/gravity.rs b/crates/minikalman/examples/gravity.rs
index 266cf08..fb114aa 100644
--- a/crates/minikalman/examples/gravity.rs
+++ b/crates/minikalman/examples/gravity.rs
@@ -181,7 +181,7 @@ fn initialize_control_matrix(filter: &mut impl ControlMatrixMut<NUM_STATES, NUM_
 
 /// Initializes the control covariance.
 fn initialize_control_covariance_matrix(
-    filter: &mut impl ProcessNoiseCovarianceMatrixMut<NUM_CONTROLS, f32>,
+    filter: &mut impl ControlProcessNoiseCovarianceMatrixMut<NUM_CONTROLS, f32>,
 ) {
     filter.as_matrix_mut().apply(|mat| {
         mat[0] = 1.0; // :)
diff --git a/crates/minikalman/src/buffers/builder.rs b/crates/minikalman/src/buffers/builder.rs
index 5cef5cc..aca8906 100644
--- a/crates/minikalman/src/buffers/builder.rs
+++ b/crates/minikalman/src/buffers/builder.rs
@@ -24,6 +24,13 @@ impl BufferBuilder {
         EstimateCovarianceMatrixBufferBuilder
     }
 
+    #[allow(non_snake_case)]
+    #[doc(alias = "process_noise_covariance_Q")]
+    pub fn direct_process_noise_covariance_Q<const STATES: usize>(
+    ) -> DirectProcessNoiseCovarianceMatrixBufferBuilder<STATES> {
+        DirectProcessNoiseCovarianceMatrixBufferBuilder
+    }
+
     pub fn control_vector_u<const CONTROLS: usize>() -> ControlVectorBufferBuilder<CONTROLS> {
         ControlVectorBufferBuilder
     }
@@ -36,9 +43,9 @@ impl BufferBuilder {
 
     #[allow(non_snake_case)]
     #[doc(alias = "control_covariance_Q")]
-    pub fn process_noise_covariance_Q<const CONTROLS: usize>(
-    ) -> ProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS> {
-        ProcessNoiseCovarianceMatrixBufferBuilder
+    pub fn control_process_noise_covariance_Q<const CONTROLS: usize>(
+    ) -> ControlProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS> {
+        ControlProcessNoiseCovarianceMatrixBufferBuilder
     }
 
     #[doc(alias = "observation_vector_z")]
@@ -128,15 +135,18 @@ pub struct StateTransitionMatrixBufferBuilder<const STATES: usize>;
 #[doc(alias = "SystemCovarianceMatrixBufferBuilder")]
 pub struct EstimateCovarianceMatrixBufferBuilder<const STATES: usize>;
 
+/// A builder for direct process noise covariance matrices (`num_states` × `num_states`).
+pub struct DirectProcessNoiseCovarianceMatrixBufferBuilder<const STATES: usize>;
+
 /// A builder for control vectors (`num_controls` × `1`).
 pub struct ControlVectorBufferBuilder<const CONTROLS: usize>;
 
 /// A builder for control transition matrices (`num_states` × `num_controls`).
 pub struct ControlTransitionMatrixBufferBuilder<const STATES: usize, const CONTROLS: usize>;
 
-/// A builder for control covariance matrices (`num_controls` × `num_controls`).
+/// A builder for control process noise covariance matrices (`num_controls` × `num_controls`).
 #[doc(alias = "ControlCovarianceMatrixBufferBuilder")]
-pub struct ProcessNoiseCovarianceMatrixBufferBuilder<const CONTROLS: usize>;
+pub struct ControlProcessNoiseCovarianceMatrixBufferBuilder<const CONTROLS: usize>;
 
 /// A builder for measurement vectors (`num_measurements` × `1`).
 pub struct ObservationVectorBufferBuilder<const OBSERVATIONS: usize>;
@@ -455,22 +465,96 @@ impl<const STATES: usize, const CONTROLS: usize>
     }
 }
 
-/// The type of owned control matrix buffers.
+/// The type of owned direct process noise matrix buffers.
 #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub type ControlCovarianceMatrixBufferOwnedType<const CONTROLS: usize, T> =
-    ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, MatrixDataBoxed<CONTROLS, CONTROLS, T>>;
+pub type DirectProcessNoiseCovarianceMatrixBufferOwnedType<const STATES: usize, T> =
+    DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, MatrixDataBoxed<STATES, STATES, T>>;
 
-impl<const CONTROLS: usize> ProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS> {
-    /// Builds a new [`ProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
+impl<const CONTROLS: usize> DirectProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS> {
+    /// Builds a new [`DirectProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
     ///
     /// ## Example
     /// ```
-    /// use minikalman::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer;
+    /// use minikalman::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer;
     /// use minikalman::prelude::*;
     ///
-    /// let buffer  = BufferBuilder::process_noise_covariance_Q::<2>().new();
+    /// let buffer  = BufferBuilder::direct_process_noise_covariance_Q::<3>().new();
     ///
-    /// let buffer: ProcessNoiseCovarianceMatrixMutBuffer<2, f32, _> = buffer;
+    /// let buffer: DirectProcessNoiseCovarianceMatrixMutBuffer<3, f32, _> = buffer;
+    /// assert_eq!(buffer.len(), 9);
+    /// ```
+    #[allow(clippy::new_ret_no_self, clippy::wrong_self_convention)]
+    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+    #[cfg(feature = "alloc")]
+    pub fn new<T>(
+        &self,
+    ) -> DirectProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+    >
+    where
+        T: Copy + Default,
+    {
+        self.new_with(T::default())
+    }
+
+    /// Builds a new [`DirectProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
+    ///
+    /// ## Example
+    /// ```
+    /// use minikalman::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer;
+    /// use minikalman::prelude::*;
+    ///
+    /// let buffer  = BufferBuilder::direct_process_noise_covariance_Q::<3>().new_with(0.0);
+    ///
+    /// let buffer: DirectProcessNoiseCovarianceMatrixMutBuffer<3, f32, _> = buffer;
+    /// assert_eq!(buffer.len(), 9);
+    /// ```
+    #[allow(clippy::new_ret_no_self, clippy::wrong_self_convention)]
+    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+    #[cfg(feature = "alloc")]
+    pub fn new_with<T>(
+        &self,
+        init: T,
+    ) -> DirectProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+    >
+    where
+        T: Copy,
+    {
+        DirectProcessNoiseCovarianceMatrixMutBuffer::<
+            CONTROLS,
+            T,
+            MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+        >::new(MatrixData::new_boxed::<CONTROLS, CONTROLS, T, _>(
+            alloc::vec![init; CONTROLS * CONTROLS],
+        ))
+    }
+}
+
+/// The type of owned control process noise matrix buffers.
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+pub type ControlProcessNoiseCovarianceMatrixBufferOwnedType<const CONTROLS: usize, T> =
+    ControlProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+    >;
+
+impl<const CONTROLS: usize> ControlProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS> {
+    /// Builds a new [`ControlProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
+    ///
+    /// ## Example
+    /// ```
+    /// use minikalman::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer;
+    /// use minikalman::prelude::*;
+    ///
+    /// let buffer  = BufferBuilder::control_process_noise_covariance_Q::<2>().new();
+    ///
+    /// let buffer: ControlProcessNoiseCovarianceMatrixMutBuffer<2, f32, _> = buffer;
     /// assert_eq!(buffer.len(), 4);
     /// ```
     #[allow(clippy::new_ret_no_self, clippy::wrong_self_convention)]
@@ -478,23 +562,27 @@ impl<const CONTROLS: usize> ProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS>
     #[cfg(feature = "alloc")]
     pub fn new<T>(
         &self,
-    ) -> ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, MatrixDataBoxed<CONTROLS, CONTROLS, T>>
+    ) -> ControlProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+    >
     where
         T: Copy + Default,
     {
         self.new_with(T::default())
     }
 
-    /// Builds a new [`ProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
+    /// Builds a new [`ControlProcessNoiseCovarianceMatrixMutBuffer`] that owns its data.
     ///
     /// ## Example
     /// ```
-    /// use minikalman::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer;
+    /// use minikalman::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer;
     /// use minikalman::prelude::*;
     ///
-    /// let buffer  = BufferBuilder::process_noise_covariance_Q::<2>().new_with(0.0);
+    /// let buffer  = BufferBuilder::control_process_noise_covariance_Q::<2>().new_with(0.0);
     ///
-    /// let buffer: ProcessNoiseCovarianceMatrixMutBuffer<2, f32, _> = buffer;
+    /// let buffer: ControlProcessNoiseCovarianceMatrixMutBuffer<2, f32, _> = buffer;
     /// assert_eq!(buffer.len(), 4);
     /// ```
     #[allow(clippy::new_ret_no_self, clippy::wrong_self_convention)]
@@ -503,13 +591,21 @@ impl<const CONTROLS: usize> ProcessNoiseCovarianceMatrixBufferBuilder<CONTROLS>
     pub fn new_with<T>(
         &self,
         init: T,
-    ) -> ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, MatrixDataBoxed<CONTROLS, CONTROLS, T>>
+    ) -> ControlProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+    >
     where
         T: Copy,
     {
-        ProcessNoiseCovarianceMatrixMutBuffer::<CONTROLS, T, MatrixDataBoxed<CONTROLS, CONTROLS, T>>::new(
-            MatrixData::new_boxed::<CONTROLS, CONTROLS, T, _>(alloc::vec![init; CONTROLS * CONTROLS]),
-        )
+        ControlProcessNoiseCovarianceMatrixMutBuffer::<
+            CONTROLS,
+            T,
+            MatrixDataBoxed<CONTROLS, CONTROLS, T>,
+        >::new(MatrixData::new_boxed::<CONTROLS, CONTROLS, T, _>(
+            alloc::vec![init; CONTROLS * CONTROLS],
+        ))
     }
 }
 
diff --git a/crates/minikalman/src/buffers/types.rs b/crates/minikalman/src/buffers/types.rs
index bf5b5a1..667cfc4 100644
--- a/crates/minikalman/src/buffers/types.rs
+++ b/crates/minikalman/src/buffers/types.rs
@@ -1,5 +1,7 @@
 mod control_matrix_buffer;
+mod control_process_noise_covariance_buffer;
 mod control_vector_buffer;
+mod direct_process_noise_covariance_buffer;
 mod estimate_covariance_matrix_buffer;
 mod innovation_covariance_matrix_buffer;
 mod innovation_vector_buffer;
@@ -7,7 +9,6 @@ mod kalman_gain_matrix_buffer;
 mod measurement_noise_covariance_matrix_buffer;
 mod measurement_vector_buffer;
 mod observation_matrix_buffer;
-mod process_noise_covariance_buffer;
 mod state_prediction_vector_buffer;
 mod state_transition_matrix_buffer;
 mod state_vector_buffer;
@@ -19,7 +20,9 @@ mod temporary_residual_covariance_inverted_matrix_buffer;
 mod temporary_state_matrix_buffer;
 
 pub use crate::buffers::types::control_matrix_buffer::*;
+pub use crate::buffers::types::control_process_noise_covariance_buffer::*;
 pub use crate::buffers::types::control_vector_buffer::*;
+pub use crate::buffers::types::direct_process_noise_covariance_buffer::*;
 pub use crate::buffers::types::estimate_covariance_matrix_buffer::*;
 pub use crate::buffers::types::innovation_covariance_matrix_buffer::*;
 pub use crate::buffers::types::innovation_vector_buffer::*;
@@ -27,7 +30,6 @@ pub use crate::buffers::types::kalman_gain_matrix_buffer::*;
 pub use crate::buffers::types::measurement_noise_covariance_matrix_buffer::*;
 pub use crate::buffers::types::measurement_vector_buffer::*;
 pub use crate::buffers::types::observation_matrix_buffer::*;
-pub use crate::buffers::types::process_noise_covariance_buffer::*;
 pub use crate::buffers::types::state_prediction_vector_buffer::*;
 pub use crate::buffers::types::state_transition_matrix_buffer::*;
 pub use crate::buffers::types::state_vector_buffer::*;
diff --git a/crates/minikalman/src/buffers/types/process_noise_covariance_buffer.rs b/crates/minikalman/src/buffers/types/control_process_noise_covariance_buffer.rs
similarity index 64%
rename from crates/minikalman/src/buffers/types/process_noise_covariance_buffer.rs
rename to crates/minikalman/src/buffers/types/control_process_noise_covariance_buffer.rs
index 242147d..f961df0 100644
--- a/crates/minikalman/src/buffers/types/process_noise_covariance_buffer.rs
+++ b/crates/minikalman/src/buffers/types/control_process_noise_covariance_buffer.rs
@@ -1,55 +1,71 @@
 use core::marker::PhantomData;
 use core::ops::{Index, IndexMut};
 
-use crate::kalman::{ProcessNoiseCovarianceMatrix, ProcessNoiseCovarianceMatrixMut};
+use crate::kalman::{ControlProcessNoiseCovarianceMatrix, ControlProcessNoiseCovarianceMatrixMut};
 use crate::matrix::{IntoInnerData, MatrixData, MatrixDataArray, MatrixDataMut, MatrixDataRef};
 use crate::matrix::{Matrix, MatrixMut};
 use crate::prelude::{RowMajorSequentialData, RowMajorSequentialDataMut};
 
-/// Immutable buffer for the control / process noise covariance matrix (`num_controls` × `num_controls`).
+/// Immutable buffer for the control process noise covariance matrix (`num_controls` × `num_controls`).
 ///
-/// Represents the uncertainty in the state transition process.
+/// This matrix represents the control process noise covariance. It quantifies the
+/// uncertainty introduced by the control inputs, reflecting how much the true state
+/// is expected to deviate from the predicted state due to noise and variations
+/// in the control process. The matrix is calculated as B×Q×Bᵀ, where B
+/// represents the control input model, and Q is the process noise covariance (this matrix).
 ///
 /// ## Example
 /// ```
-/// use minikalman::buffers::types::ProcessNoiseCovarianceMatrixBuffer;
+/// use minikalman::buffers::types::ControlProcessNoiseCovarianceMatrixBuffer;
 /// use minikalman::prelude::*;
 ///
 /// // From owned data
-/// let buffer = ProcessNoiseCovarianceMatrixBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
+/// let buffer = ControlProcessNoiseCovarianceMatrixBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
 ///
 /// // From a reference
 /// let data = [0.0; 4];
-/// let buffer = ProcessNoiseCovarianceMatrixBuffer::<2, f32, _>::from(data.as_ref());
+/// let buffer = ControlProcessNoiseCovarianceMatrixBuffer::<2, f32, _>::from(data.as_ref());
 /// ```
 #[doc(alias = "ControlCovarianceMatrixBuffer")]
-pub struct ProcessNoiseCovarianceMatrixBuffer<const CONTROLS: usize, T, M>(M, PhantomData<T>)
+pub struct ControlProcessNoiseCovarianceMatrixBuffer<const CONTROLS: usize, T, M>(
+    M,
+    PhantomData<T>,
+)
 where
     M: Matrix<CONTROLS, CONTROLS, T>;
 
-/// Mutable buffer for the control / process noise covariance matrix (`num_controls` × `num_controls`).
+/// Mutable buffer for the control process noise covariance matrix (`num_controls` × `num_controls`).
+///
+/// This matrix represents the control process noise covariance. It quantifies the
+/// uncertainty introduced by the control inputs, reflecting how much the true state
+/// is expected to deviate from the predicted state due to noise and variations
+/// in the control process. The matrix is calculated as B×Q×Bᵀ, where B
+/// represents the control input model, and Q is the process noise covariance (this matrix).
 ///
 /// ## Example
 /// ```
-/// use minikalman::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer;
+/// use minikalman::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer;
 /// use minikalman::prelude::*;
 ///
 /// // From owned data
-/// let buffer = ProcessNoiseCovarianceMatrixMutBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
+/// let buffer = ControlProcessNoiseCovarianceMatrixMutBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
 ///
 /// // From a reference
 /// let mut data = [0.0; 4];
-/// let buffer = ProcessNoiseCovarianceMatrixMutBuffer::<2, f32, _>::from(data.as_mut_slice());
+/// let buffer = ControlProcessNoiseCovarianceMatrixMutBuffer::<2, f32, _>::from(data.as_mut_slice());
 /// ```
 #[doc(alias = "ControlCovarianceMatrixMutBuffer")]
-pub struct ProcessNoiseCovarianceMatrixMutBuffer<const CONTROLS: usize, T, M>(M, PhantomData<T>)
+pub struct ControlProcessNoiseCovarianceMatrixMutBuffer<const CONTROLS: usize, T, M>(
+    M,
+    PhantomData<T>,
+)
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>;
 
 // -----------------------------------------------------------
 
 impl<const CONTROLS: usize, const TOTAL: usize, T> From<[T; TOTAL]>
-    for ProcessNoiseCovarianceMatrixBuffer<
+    for ControlProcessNoiseCovarianceMatrixBuffer<
         CONTROLS,
         T,
         MatrixDataArray<CONTROLS, CONTROLS, TOTAL, T>,
@@ -65,7 +81,11 @@ impl<const CONTROLS: usize, const TOTAL: usize, T> From<[T; TOTAL]>
 }
 
 impl<'a, const CONTROLS: usize, T> From<&'a [T]>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, MatrixDataRef<'a, CONTROLS, CONTROLS, T>>
+    for ControlProcessNoiseCovarianceMatrixBuffer<
+        CONTROLS,
+        T,
+        MatrixDataRef<'a, CONTROLS, CONTROLS, T>,
+    >
 {
     fn from(value: &'a [T]) -> Self {
         #[cfg(not(feature = "no_assert"))]
@@ -77,7 +97,11 @@ impl<'a, const CONTROLS: usize, T> From<&'a [T]>
 }
 
 impl<'a, const CONTROLS: usize, T> From<&'a mut [T]>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, MatrixDataRef<'a, CONTROLS, CONTROLS, T>>
+    for ControlProcessNoiseCovarianceMatrixBuffer<
+        CONTROLS,
+        T,
+        MatrixDataRef<'a, CONTROLS, CONTROLS, T>,
+    >
 {
     fn from(value: &'a mut [T]) -> Self {
         #[cfg(not(feature = "no_assert"))]
@@ -89,7 +113,11 @@ impl<'a, const CONTROLS: usize, T> From<&'a mut [T]>
 }
 
 impl<'a, const CONTROLS: usize, T> From<&'a mut [T]>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, MatrixDataMut<'a, CONTROLS, CONTROLS, T>>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<
+        CONTROLS,
+        T,
+        MatrixDataMut<'a, CONTROLS, CONTROLS, T>,
+    >
 {
     fn from(value: &'a mut [T]) -> Self {
         #[cfg(not(feature = "no_assert"))]
@@ -101,7 +129,7 @@ impl<'a, const CONTROLS: usize, T> From<&'a mut [T]>
 }
 
 impl<const CONTROLS: usize, const TOTAL: usize, T> From<[T; TOTAL]>
-    for ProcessNoiseCovarianceMatrixMutBuffer<
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<
         CONTROLS,
         T,
         MatrixDataArray<CONTROLS, CONTROLS, TOTAL, T>,
@@ -118,7 +146,7 @@ impl<const CONTROLS: usize, const TOTAL: usize, T> From<[T; TOTAL]>
 
 // -----------------------------------------------------------
 
-impl<const CONTROLS: usize, T, M> ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+impl<const CONTROLS: usize, T, M> ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: Matrix<CONTROLS, CONTROLS, T>,
 {
@@ -136,7 +164,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> RowMajorSequentialData<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: Matrix<CONTROLS, CONTROLS, T>,
 {
@@ -147,14 +175,14 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> Matrix<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: Matrix<CONTROLS, CONTROLS, T>,
 {
 }
 
-impl<const CONTROLS: usize, T, M> ProcessNoiseCovarianceMatrix<CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+impl<const CONTROLS: usize, T, M> ControlProcessNoiseCovarianceMatrix<CONTROLS, T>
+    for ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: Matrix<CONTROLS, CONTROLS, T>,
 {
@@ -165,7 +193,7 @@ where
     }
 }
 
-impl<const CONTROLS: usize, T, M> ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+impl<const CONTROLS: usize, T, M> ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -188,7 +216,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> RowMajorSequentialData<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -199,7 +227,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> RowMajorSequentialDataMut<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -210,21 +238,21 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> Matrix<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
 }
 
 impl<const CONTROLS: usize, T, M> MatrixMut<CONTROLS, CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
 }
 
-impl<const CONTROLS: usize, T, M> ProcessNoiseCovarianceMatrix<CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+impl<const CONTROLS: usize, T, M> ControlProcessNoiseCovarianceMatrix<CONTROLS, T>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -235,8 +263,8 @@ where
     }
 }
 
-impl<const CONTROLS: usize, T, M> ProcessNoiseCovarianceMatrixMut<CONTROLS, T>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+impl<const CONTROLS: usize, T, M> ControlProcessNoiseCovarianceMatrixMut<CONTROLS, T>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -248,7 +276,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> Index<usize>
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: Matrix<CONTROLS, CONTROLS, T>,
 {
@@ -260,7 +288,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> Index<usize>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -272,7 +300,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> IndexMut<usize>
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T>,
 {
@@ -284,7 +312,7 @@ where
 // -----------------------------------------------------------
 
 impl<const CONTROLS: usize, T, M> IntoInnerData
-    for ProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T> + IntoInnerData,
 {
@@ -296,7 +324,7 @@ where
 }
 
 impl<const CONTROLS: usize, T, M> IntoInnerData
-    for ProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
+    for ControlProcessNoiseCovarianceMatrixMutBuffer<CONTROLS, T, M>
 where
     M: MatrixMut<CONTROLS, CONTROLS, T> + IntoInnerData,
 {
@@ -313,7 +341,7 @@ mod tests {
 
     #[test]
     fn test_from_array() {
-        let value: ProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 100].into();
+        let value: ControlProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 100].into();
         assert_eq!(value.len(), 25);
         assert!(!value.is_empty());
         assert!(value.is_valid());
@@ -322,7 +350,7 @@ mod tests {
     #[test]
     fn test_from_ref() {
         let data = [0.0_f32; 100];
-        let value: ProcessNoiseCovarianceMatrixBuffer<5, f32, _> = data.as_ref().into();
+        let value: ControlProcessNoiseCovarianceMatrixBuffer<5, f32, _> = data.as_ref().into();
         assert_eq!(value.len(), 25);
         assert!(value.is_valid());
         assert!(!value.is_empty());
@@ -332,7 +360,8 @@ mod tests {
     #[test]
     fn test_from_mut() {
         let mut data = [0.0_f32; 100];
-        let value: ProcessNoiseCovarianceMatrixBuffer<5, f32, _> = data.as_mut_slice().into();
+        let value: ControlProcessNoiseCovarianceMatrixBuffer<5, f32, _> =
+            data.as_mut_slice().into();
         assert_eq!(value.len(), 25);
         assert!(value.is_valid());
         assert!(!value.is_empty());
@@ -342,13 +371,13 @@ mod tests {
     #[test]
     #[cfg(feature = "no_assert")]
     fn test_from_array_invalid_size() {
-        let value: ProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 1].into();
+        let value: ControlProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 1].into();
         assert!(!value.is_valid());
     }
 
     #[test]
     fn test_mut_from_array() {
-        let value: ProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 100].into();
+        let value: ControlProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 100].into();
         assert_eq!(value.len(), 25);
         assert!(!value.is_empty());
         assert!(value.is_valid());
@@ -357,7 +386,8 @@ mod tests {
     #[test]
     fn test_mut_from_mut() {
         let mut data = [0.0_f32; 100];
-        let value: ProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = data.as_mut_slice().into();
+        let value: ControlProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> =
+            data.as_mut_slice().into();
         assert_eq!(value.len(), 25);
         assert!(!value.is_empty());
         assert!(value.is_valid());
@@ -367,14 +397,14 @@ mod tests {
     #[test]
     #[cfg(feature = "no_assert")]
     fn test_mut_from_array_invalid_size() {
-        let value: ProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 1].into();
+        let value: ControlProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 1].into();
         assert!(!value.is_valid());
     }
 
     #[test]
     #[rustfmt::skip]
     fn test_access() {
-        let mut value: ProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 25].into();
+        let mut value: ControlProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 25].into();
 
         // Set values.
         {
diff --git a/crates/minikalman/src/buffers/types/direct_process_noise_covariance_buffer.rs b/crates/minikalman/src/buffers/types/direct_process_noise_covariance_buffer.rs
new file mode 100644
index 0000000..1c9d13c
--- /dev/null
+++ b/crates/minikalman/src/buffers/types/direct_process_noise_covariance_buffer.rs
@@ -0,0 +1,413 @@
+use core::marker::PhantomData;
+use core::ops::{Index, IndexMut};
+
+use crate::kalman::{DirectProcessNoiseCovarianceMatrix, DirectProcessNoiseCovarianceMatrixMut};
+use crate::matrix::{IntoInnerData, MatrixData, MatrixDataArray, MatrixDataMut, MatrixDataRef};
+use crate::matrix::{Matrix, MatrixMut};
+use crate::prelude::{RowMajorSequentialData, RowMajorSequentialDataMut};
+
+/// Immutable buffer for the direct process noise covariance matrix (`num_states` × `num_states`).
+///
+/// Represents the uncertainty in the state transition process.
+///
+/// ## Example
+/// ```
+/// use minikalman::buffers::types::DirectProcessNoiseCovarianceMatrixBuffer;
+/// use minikalman::prelude::*;
+///
+/// // From owned data
+/// let buffer = DirectProcessNoiseCovarianceMatrixBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
+///
+/// // From a reference
+/// let data = [0.0; 4];
+/// let buffer = DirectProcessNoiseCovarianceMatrixBuffer::<2, f32, _>::from(data.as_ref());
+/// ```
+pub struct DirectProcessNoiseCovarianceMatrixBuffer<const STATES: usize, T, M>(M, PhantomData<T>)
+where
+    M: Matrix<STATES, STATES, T>;
+
+/// Mutable buffer for the direct process noise covariance matrix (`num_states` × `num_states`).
+///
+/// ## Example
+/// ```
+/// use minikalman::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer;
+/// use minikalman::prelude::*;
+///
+/// // From owned data
+/// let buffer = DirectProcessNoiseCovarianceMatrixMutBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));
+///
+/// // From a reference
+/// let mut data = [0.0; 4];
+/// let buffer = DirectProcessNoiseCovarianceMatrixMutBuffer::<2, f32, _>::from(data.as_mut_slice());
+/// ```
+pub struct DirectProcessNoiseCovarianceMatrixMutBuffer<const STATES: usize, T, M>(
+    M,
+    PhantomData<T>,
+)
+where
+    M: MatrixMut<STATES, STATES, T>;
+
+// -----------------------------------------------------------
+
+impl<const STATES: usize, const TOTAL: usize, T> From<[T; TOTAL]>
+    for DirectProcessNoiseCovarianceMatrixBuffer<
+        STATES,
+        T,
+        MatrixDataArray<STATES, STATES, TOTAL, T>,
+    >
+{
+    fn from(value: [T; TOTAL]) -> Self {
+        #[cfg(not(feature = "no_assert"))]
+        {
+            debug_assert!(STATES * STATES <= TOTAL);
+        }
+        Self::new(MatrixData::new_array::<STATES, STATES, TOTAL, T>(value))
+    }
+}
+
+impl<'a, const STATES: usize, T> From<&'a [T]>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, MatrixDataRef<'a, STATES, STATES, T>>
+{
+    fn from(value: &'a [T]) -> Self {
+        #[cfg(not(feature = "no_assert"))]
+        {
+            debug_assert!(STATES * STATES <= value.len());
+        }
+        Self::new(MatrixData::new_ref::<STATES, STATES, T>(value))
+    }
+}
+
+impl<'a, const STATES: usize, T> From<&'a mut [T]>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, MatrixDataRef<'a, STATES, STATES, T>>
+{
+    fn from(value: &'a mut [T]) -> Self {
+        #[cfg(not(feature = "no_assert"))]
+        {
+            debug_assert!(STATES * STATES <= value.len());
+        }
+        Self::new(MatrixData::new_ref::<STATES, STATES, T>(value))
+    }
+}
+
+impl<'a, const STATES: usize, T> From<&'a mut [T]>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, MatrixDataMut<'a, STATES, STATES, T>>
+{
+    fn from(value: &'a mut [T]) -> Self {
+        #[cfg(not(feature = "no_assert"))]
+        {
+            debug_assert!(STATES * STATES <= value.len());
+        }
+        Self::new(MatrixData::new_mut::<STATES, STATES, T>(value))
+    }
+}
+
+impl<const STATES: usize, const TOTAL: usize, T> From<[T; TOTAL]>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<
+        STATES,
+        T,
+        MatrixDataArray<STATES, STATES, TOTAL, T>,
+    >
+{
+    fn from(value: [T; TOTAL]) -> Self {
+        #[cfg(not(feature = "no_assert"))]
+        {
+            debug_assert!(STATES * STATES <= TOTAL);
+        }
+        Self::new(MatrixData::new_array::<STATES, STATES, TOTAL, T>(value))
+    }
+}
+
+// -----------------------------------------------------------
+
+impl<const STATES: usize, T, M> DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: Matrix<STATES, STATES, T>,
+{
+    pub const fn new(matrix: M) -> Self {
+        Self(matrix, PhantomData)
+    }
+
+    pub const fn len(&self) -> usize {
+        STATES * STATES
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        STATES == 0
+    }
+}
+
+impl<const STATES: usize, T, M> RowMajorSequentialData<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: Matrix<STATES, STATES, T>,
+{
+    #[inline(always)]
+    fn as_slice(&self) -> &[T] {
+        self.0.as_slice()
+    }
+}
+
+impl<const STATES: usize, T, M> Matrix<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: Matrix<STATES, STATES, T>,
+{
+}
+
+impl<const STATES: usize, T, M> DirectProcessNoiseCovarianceMatrix<STATES, T>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: Matrix<STATES, STATES, T>,
+{
+    type Target = M;
+
+    fn as_matrix(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const STATES: usize, T, M> DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    pub const fn new(matrix: M) -> Self {
+        Self(matrix, PhantomData)
+    }
+
+    pub const fn len(&self) -> usize {
+        STATES * STATES
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        STATES == 0
+    }
+
+    /// Ensures the underlying buffer has enough space for the expected number of values.
+    pub fn is_valid(&self) -> bool {
+        self.0.is_valid()
+    }
+}
+
+impl<const STATES: usize, T, M> RowMajorSequentialData<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    #[inline(always)]
+    fn as_slice(&self) -> &[T] {
+        self.0.as_slice()
+    }
+}
+
+impl<const STATES: usize, T, M> RowMajorSequentialDataMut<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    #[inline(always)]
+    fn as_mut_slice(&mut self) -> &mut [T] {
+        self.0.as_mut_slice()
+    }
+}
+
+impl<const STATES: usize, T, M> Matrix<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+}
+
+impl<const STATES: usize, T, M> MatrixMut<STATES, STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+}
+
+impl<const STATES: usize, T, M> DirectProcessNoiseCovarianceMatrix<STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    type Target = M;
+
+    fn as_matrix(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const STATES: usize, T, M> DirectProcessNoiseCovarianceMatrixMut<STATES, T>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    type TargetMut = M;
+
+    fn as_matrix_mut(&mut self) -> &mut Self::TargetMut {
+        &mut self.0
+    }
+}
+
+impl<const STATES: usize, T, M> Index<usize>
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: Matrix<STATES, STATES, T>,
+{
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+
+impl<const STATES: usize, T, M> Index<usize>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+
+impl<const STATES: usize, T, M> IndexMut<usize>
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T>,
+{
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        self.0.index_mut(index)
+    }
+}
+
+// -----------------------------------------------------------
+
+impl<const STATES: usize, T, M> IntoInnerData
+    for DirectProcessNoiseCovarianceMatrixBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T> + IntoInnerData,
+{
+    type Target = M::Target;
+
+    fn into_inner(self) -> Self::Target {
+        self.0.into_inner()
+    }
+}
+
+impl<const STATES: usize, T, M> IntoInnerData
+    for DirectProcessNoiseCovarianceMatrixMutBuffer<STATES, T, M>
+where
+    M: MatrixMut<STATES, STATES, T> + IntoInnerData,
+{
+    type Target = M::Target;
+
+    fn into_inner(self) -> Self::Target {
+        self.0.into_inner()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_array() {
+        let value: DirectProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 100].into();
+        assert_eq!(value.len(), 25);
+        assert!(!value.is_empty());
+        assert!(value.is_valid());
+    }
+
+    #[test]
+    fn test_from_ref() {
+        let data = [0.0_f32; 100];
+        let value: DirectProcessNoiseCovarianceMatrixBuffer<5, f32, _> = data.as_ref().into();
+        assert_eq!(value.len(), 25);
+        assert!(value.is_valid());
+        assert!(!value.is_empty());
+        assert!(core::ptr::eq(value.as_slice(), &data));
+    }
+
+    #[test]
+    fn test_from_mut() {
+        let mut data = [0.0_f32; 100];
+        let value: DirectProcessNoiseCovarianceMatrixBuffer<5, f32, _> = data.as_mut_slice().into();
+        assert_eq!(value.len(), 25);
+        assert!(value.is_valid());
+        assert!(!value.is_empty());
+        assert!(core::ptr::eq(value.as_slice(), &data));
+    }
+
+    #[test]
+    #[cfg(feature = "no_assert")]
+    fn test_from_array_invalid_size() {
+        let value: DirectProcessNoiseCovarianceMatrixBuffer<5, f32, _> = [0.0; 1].into();
+        assert!(!value.is_valid());
+    }
+
+    #[test]
+    fn test_mut_from_array() {
+        let value: DirectProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 100].into();
+        assert_eq!(value.len(), 25);
+        assert!(!value.is_empty());
+        assert!(value.is_valid());
+    }
+
+    #[test]
+    fn test_mut_from_mut() {
+        let mut data = [0.0_f32; 100];
+        let value: DirectProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> =
+            data.as_mut_slice().into();
+        assert_eq!(value.len(), 25);
+        assert!(!value.is_empty());
+        assert!(value.is_valid());
+        assert!(core::ptr::eq(value.as_slice(), &data));
+    }
+
+    #[test]
+    #[cfg(feature = "no_assert")]
+    fn test_mut_from_array_invalid_size() {
+        let value: DirectProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 1].into();
+        assert!(!value.is_valid());
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn test_access() {
+        let mut value: DirectProcessNoiseCovarianceMatrixMutBuffer<5, f32, _> = [0.0; 25].into();
+
+        // Set values.
+        {
+            let matrix = value.as_matrix_mut();
+            for i in 0..matrix.cols() {
+                matrix.set_symmetric(0, i, i as _);
+                matrix.set_at(i, i, i as _);
+            }
+        }
+
+        // Update values.
+        for i in 0..value.len() {
+            value[i] += 10.0;
+        }
+
+        // Get values.
+        {
+            let matrix = value.as_matrix();
+            for i in 0..matrix.rows() {
+                assert_eq!(matrix.get_at(0, i), 10.0 + i as f32);
+                assert_eq!(matrix.get_at(i, 0), 10.0 + i as f32);
+            }
+        }
+
+        assert_eq!(value.into_inner(),
+                   [
+                       10.0, 11.0, 12.0, 13.0, 14.0,
+                       11.0, 11.0, 10.0, 10.0, 10.0,
+                       12.0, 10.0, 12.0, 10.0, 10.0,
+                       13.0, 10.0, 10.0, 13.0, 10.0,
+                       14.0, 10.0, 10.0, 10.0, 14.0,
+                   ]);
+    }
+}
diff --git a/crates/minikalman/src/controls.rs b/crates/minikalman/src/controls.rs
index d38b1f1..1b68ca6 100644
--- a/crates/minikalman/src/controls.rs
+++ b/crates/minikalman/src/controls.rs
@@ -34,7 +34,7 @@ impl<B, U, Q, TempBQ> ControlBuilder<B, U, Q, TempBQ> {
         T: MatrixDataType,
         B: ControlMatrix<STATES, CONTROLS, T>,
         U: ControlVector<CONTROLS, T>,
-        Q: ProcessNoiseCovarianceMatrix<CONTROLS, T>,
+        Q: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>,
         TempBQ: TemporaryBQMatrix<STATES, CONTROLS, T>,
     {
         Control::<STATES, CONTROLS, T, _, _, _, _> {
@@ -153,7 +153,7 @@ where
 impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
     Control<STATES, CONTROLS, T, B, U, Q, TempBQ>
 where
-    Q: ProcessNoiseCovarianceMatrix<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>,
 {
     /// Gets a reference to the control covariance matrix Q.
     ///
@@ -170,7 +170,7 @@ where
 impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
     Control<STATES, CONTROLS, T, B, U, Q, TempBQ>
 where
-    Q: ProcessNoiseCovarianceMatrixMut<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrixMut<CONTROLS, T>,
 {
     /// Gets a mutable reference to the control covariance matrix Q.
     ///
@@ -190,7 +190,7 @@ impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
 where
     U: ControlVector<CONTROLS, T>,
     B: ControlMatrix<STATES, CONTROLS, T>,
-    Q: ProcessNoiseCovarianceMatrix<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>,
     TempBQ: TemporaryBQMatrix<STATES, CONTROLS, T>,
     T: MatrixDataType,
 {
@@ -291,7 +291,7 @@ impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
     KalmanFilterProcessNoiseCovariance<CONTROLS, T>
     for Control<STATES, CONTROLS, T, B, U, Q, TempBQ>
 where
-    Q: ProcessNoiseCovarianceMatrix<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>,
 {
     type ProcessNoiseCovarianceMatrix = Q;
 
@@ -303,7 +303,7 @@ where
 impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
     KalmanFilterControlCovarianceMut<CONTROLS, T> for Control<STATES, CONTROLS, T, B, U, Q, TempBQ>
 where
-    Q: ProcessNoiseCovarianceMatrixMut<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrixMut<CONTROLS, T>,
 {
     type ProcessNoiseCovarianceMatrixMut = Q;
 
@@ -317,7 +317,7 @@ impl<const STATES: usize, const CONTROLS: usize, T, B, U, Q, TempBQ>
 where
     U: ControlVector<CONTROLS, T>,
     B: ControlMatrix<STATES, CONTROLS, T>,
-    Q: ProcessNoiseCovarianceMatrix<CONTROLS, T>,
+    Q: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>,
     TempBQ: TemporaryBQMatrix<STATES, CONTROLS, T>,
     T: MatrixDataType,
 {
@@ -365,11 +365,12 @@ mod tests {
         let x = BufferBuilder::state_vector_x::<NUM_STATES>().new();
         let A = BufferBuilder::system_matrix_A::<NUM_STATES>().new();
         let P = BufferBuilder::estimate_covariance_P::<NUM_STATES>().new();
+        let Q_direct = BufferBuilder::direct_process_noise_covariance_Q::<NUM_STATES>().new();
 
         // Control buffers.
         let u = BufferBuilder::control_vector_u::<NUM_CONTROLS>().new();
         let B = BufferBuilder::control_matrix_B::<NUM_STATES, NUM_CONTROLS>().new();
-        let Q = BufferBuilder::process_noise_covariance_Q::<NUM_CONTROLS>().new();
+        let Q_control = BufferBuilder::control_process_noise_covariance_Q::<NUM_CONTROLS>().new();
 
         // Filter temporaries.
         let temp_x = BufferBuilder::state_prediction_temp_x::<NUM_STATES>().new();
@@ -378,8 +379,10 @@ mod tests {
         // Control temporaries
         let temp_BQ = BufferBuilder::temp_BQ::<NUM_STATES, NUM_CONTROLS>().new();
 
-        let mut filter = RegularKalmanBuilder::new::<NUM_STATES, f32>(A, x, P, temp_x, temp_P);
-        let mut control = ControlBuilder::new::<NUM_STATES, NUM_CONTROLS, f32>(B, u, Q, temp_BQ);
+        let mut filter =
+            RegularKalmanBuilder::new::<NUM_STATES, f32>(A, x, P, Q_direct, temp_x, temp_P);
+        let mut control =
+            ControlBuilder::new::<NUM_STATES, NUM_CONTROLS, f32>(B, u, Q_control, temp_BQ);
 
         // State transition is identity.
         filter.state_transition_mut().apply(|mat| {
diff --git a/crates/minikalman/src/kalman/extended.rs b/crates/minikalman/src/kalman/extended.rs
index c0bc16f..24c4211 100644
--- a/crates/minikalman/src/kalman/extended.rs
+++ b/crates/minikalman/src/kalman/extended.rs
@@ -7,29 +7,27 @@ use core::marker::PhantomData;
 
 /// A builder for a [`ExtendedKalman`] filter instances.
 #[allow(clippy::type_complexity)]
-pub struct ExtendedKalmanBuilder<A, X, P, PX, TempP> {
+pub struct ExtendedKalmanBuilder<A, X, P, Q, PX, TempP> {
     _phantom: (
         PhantomData<A>,
         PhantomData<X>,
         PhantomData<P>,
+        PhantomData<Q>,
         PhantomData<PX>,
         PhantomData<TempP>,
     ),
 }
 
-impl<A, X, P, PX, TempP> ExtendedKalmanBuilder<A, X, P, PX, TempP> {
+impl<A, X, P, Q, PX, TempP> ExtendedKalmanBuilder<A, X, P, Q, PX, TempP> {
     /// Initializes a Kalman filter instance.
     ///
     /// ## Arguments
-    /// * `A` - The state transition matrix (`STATES` × `STATES`), or the Jacobian in an EKF.
+    /// * `A` - The Jacobian of the state transition matrix (`STATES` × `STATES`).
     /// * `x` - The state vector (`STATES` × `1`).
-    /// * `B` - The control transition matrix (`STATES` × `CONTROLS`).
-    /// * `u` - The control vector (`CONTROLS` × `1`).
     /// * `P` - The state covariance matrix (`STATES` × `STATES`).
-    /// * `Q` - The control covariance matrix (`CONTROLS` × `CONTROLS`).
+    /// * `Q` - The direct process noise matrix (`STATES` × `STATES`).
     /// * `predictedX` - The temporary vector for predicted states (`STATES` × `1`).
     /// * `temp_P` - The temporary vector for P calculation (`STATES` × `STATES`).
-    /// * `temp_BQ` - The temporary vector for B×Q calculation (`STATES` × `CONTROLS`).
     ///
     /// ## Example
     ///
@@ -44,6 +42,7 @@ impl<A, X, P, PX, TempP> ExtendedKalmanBuilder<A, X, P, PX, TempP> {
     /// impl_buffer_x!(mut gravity_x, NUM_STATES, f32, 0.0);
     /// impl_buffer_A!(mut gravity_A, NUM_STATES, f32, 0.0);
     /// impl_buffer_P!(mut gravity_P, NUM_STATES, f32, 0.0);
+    /// impl_buffer_Q_direct!(mut gravity_Q, NUM_STATES, f32, 0.0);
     ///
     /// // Filter temporaries.
     /// impl_buffer_temp_x!(mut gravity_temp_x, NUM_STATES, f32, 0.0);
@@ -53,6 +52,7 @@ impl<A, X, P, PX, TempP> ExtendedKalmanBuilder<A, X, P, PX, TempP> {
     ///     gravity_A,
     ///     gravity_x,
     ///     gravity_P,
+    ///     gravity_Q,
     ///     gravity_temp_x,
     ///     gravity_temp_P,
     ///  );
@@ -62,21 +62,24 @@ impl<A, X, P, PX, TempP> ExtendedKalmanBuilder<A, X, P, PX, TempP> {
         A: A,
         x: X,
         P: P,
+        Q: Q,
         predicted_x: PX,
         temp_P: TempP,
-    ) -> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+    ) -> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
     where
         T: MatrixDataType,
         A: StateTransitionMatrix<STATES, T>,
         X: StateVectorMut<STATES, T>,
         P: EstimateCovarianceMatrix<STATES, T>,
+        Q: DirectProcessNoiseCovarianceMatrix<STATES, T>,
         PX: PredictedStateEstimateVector<STATES, T>,
         TempP: TemporaryStateMatrix<STATES, T>,
     {
-        ExtendedKalman::<STATES, T, _, _, _, _, _> {
+        ExtendedKalman::<STATES, T, _, _, _, _, _, _> {
             x,
             A,
             P,
+            Q,
             predicted_x,
             temp_P,
             _phantom: Default::default(),
@@ -86,7 +89,7 @@ impl<A, X, P, PX, TempP> ExtendedKalmanBuilder<A, X, P, PX, TempP> {
 
 /// Kalman Filter structure.  See [`ExtendedKalmanBuilder`] for construction.
 #[allow(non_snake_case, unused)]
-pub struct ExtendedKalman<const STATES: usize, T, A, X, P, PX, TempP> {
+pub struct ExtendedKalman<const STATES: usize, T, A, X, P, Q, PX, TempP> {
     /// State vector.
     x: X,
 
@@ -95,11 +98,16 @@ pub struct ExtendedKalman<const STATES: usize, T, A, X, P, PX, TempP> {
     /// See also [`P`].
     A: A,
 
-    /// System covariance matrix.
+    /// Estimation covariance matrix.
     ///
     /// See also [`A`].
     P: P,
 
+    /// Direct process noise matrix.
+    ///
+    /// See also [`P`].
+    Q: Q,
+
     /// x-sized temporary vector.
     predicted_x: PX,
 
@@ -111,14 +119,16 @@ pub struct ExtendedKalman<const STATES: usize, T, A, X, P, PX, TempP> {
     _phantom: PhantomData<T>,
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP> {
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP>
+    ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
+{
     /// Returns the number of states.
     pub const fn states(&self) -> usize {
         STATES
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVector<STATES, T>,
 {
@@ -132,7 +142,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
 {
@@ -147,7 +157,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrix<STATES, T>,
 {
@@ -167,7 +177,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrixMut<STATES, T>,
 {
@@ -192,7 +202,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -218,7 +228,41 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X, P, PX, TempP> {
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
+where
+    P: DirectProcessNoiseCovarianceMatrix<STATES, T>,
+{
+    /// Gets a reference to the direct process noise matrix Q.
+    ///
+    /// This matrix represents the process noise covariance. It quantifies the uncertainty
+    /// introduced by the model dynamics and process variations, providing a measure of
+    /// how much the true state is expected to deviate from the predicted state due to
+    /// inherent system noise and external influences.
+    #[inline(always)]
+    pub fn direct_process_noise(&self) -> &Q {
+        &self.Q
+    }
+}
+
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
+where
+    P: DirectProcessNoiseCovarianceMatrixMut<STATES, T>,
+{
+    /// Gets a mutable reference to the direct process noise matrix Q.
+    ///
+    /// This matrix represents the process noise covariance. It quantifies the uncertainty
+    /// introduced by the model dynamics and process variations, providing a measure of
+    /// how much the true state is expected to deviate from the predicted state due to
+    /// inherent system noise and external influences.
+    #[inline(always)]
+    pub fn direct_process_noise_mut(&mut self) -> &mut Q {
+        &mut self.Q
+    }
+}
+
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP>
+    ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
+{
     /// Performs a nonlinear state transition only involving the current state.
     ///
     /// ## Extended Kalman Filters
@@ -245,6 +289,7 @@ impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X,
     /// # impl_buffer_x!(mut gravity_x, NUM_STATES, f32, 0.0);
     /// # impl_buffer_A!(mut gravity_A, NUM_STATES, f32, 0.0);
     /// # impl_buffer_P!(mut gravity_P, NUM_STATES, f32, 0.0);
+    /// # impl_buffer_Q_direct!(mut gravity_Q, NUM_STATES, f32, 0.0);
     /// #
     /// # // Filter temporaries.
     /// # impl_buffer_temp_x!(mut gravity_temp_x, NUM_STATES, f32, 0.0);
@@ -254,6 +299,7 @@ impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X,
     /// #     gravity_A,
     /// #     gravity_x,
     /// #     gravity_P,
+    /// #     gravity_Q,
     /// #     gravity_temp_x,
     /// #     gravity_temp_P,
     /// #  );
@@ -465,13 +511,13 @@ impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalman<STATES, T, A, X,
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterNumStates<STATES>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterNumStates<STATES>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 {
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateVector<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateVector<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVector<STATES, T>,
 {
@@ -483,8 +529,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateVectorMut<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateVectorMut<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
 {
@@ -496,8 +542,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalmanFilterStateTransition<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> ExtendedKalmanFilterStateTransition<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrix<STATES, T>,
 {
@@ -509,8 +555,9 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> ExtendedKalmanFilterStateTransitionMut<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP>
+    ExtendedKalmanFilterStateTransitionMut<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrixMut<STATES, T>,
 {
@@ -522,8 +569,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterEstimateCovariance<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterEstimateCovariance<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -535,8 +582,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterEstimateCovarianceMut<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterEstimateCovarianceMut<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -548,8 +595,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterNonlinearPredict<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterNonlinearPredict<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
     A: StateTransitionMatrix<STATES, T>,
@@ -569,8 +616,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterNonlinearUpdate<STATES, T>
-    for ExtendedKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterNonlinearUpdate<STATES, T>
+    for ExtendedKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
     X: StateVectorMut<STATES, T>,
diff --git a/crates/minikalman/src/kalman/filter_trait.rs b/crates/minikalman/src/kalman/filter_trait.rs
index 5331012..9337738 100644
--- a/crates/minikalman/src/kalman/filter_trait.rs
+++ b/crates/minikalman/src/kalman/filter_trait.rs
@@ -385,7 +385,7 @@ pub trait KalmanFilterControlTransitionMut<const STATES: usize, const CONTROLS:
 
 #[doc(alias = "KalmanFilterControlCovariance")]
 pub trait KalmanFilterProcessNoiseCovariance<const CONTROLS: usize, T> {
-    type ProcessNoiseCovarianceMatrix: ProcessNoiseCovarianceMatrix<CONTROLS, T>;
+    type ProcessNoiseCovarianceMatrix: ControlProcessNoiseCovarianceMatrix<CONTROLS, T>;
 
     /// Gets a reference to the control covariance matrix Q.
     ///
@@ -399,7 +399,7 @@ pub trait KalmanFilterProcessNoiseCovariance<const CONTROLS: usize, T> {
 pub trait KalmanFilterControlCovarianceMut<const CONTROLS: usize, T>:
     KalmanFilterProcessNoiseCovariance<CONTROLS, T>
 {
-    type ProcessNoiseCovarianceMatrixMut: ProcessNoiseCovarianceMatrixMut<CONTROLS, T>;
+    type ProcessNoiseCovarianceMatrixMut: ControlProcessNoiseCovarianceMatrixMut<CONTROLS, T>;
 
     /// Gets a mutable reference to the control covariance matrix Q.
     ///
diff --git a/crates/minikalman/src/kalman/matrix_types.rs b/crates/minikalman/src/kalman/matrix_types.rs
index 2c473d4..4797f16 100644
--- a/crates/minikalman/src/kalman/matrix_types.rs
+++ b/crates/minikalman/src/kalman/matrix_types.rs
@@ -122,10 +122,54 @@ pub trait ControlMatrixMut<const STATES: usize, const CONTROLS: usize, T = f32>:
 
 /// Process noise covariance matrix. Represents the uncertainty in the state transition process.
 ///
-/// Immutable variant. For a mutable variant, see [`ProcessNoiseCovarianceMatrixMut`].
+/// This matrix represents the direct process noise covariance. It quantifies the
+/// uncertainty introduced by inherent system dynamics and external disturbances,
+/// providing a measure of how much the true state is expected to deviate from the
+/// predicted state due to these process variations.
+///
+/// Immutable variant. For a mutable variant, see [`DirectProcessNoiseCovarianceMatrixMut`].
 #[doc(alias = "ControlCovarianceMatrix")]
 #[doc(alias = "Prozessrauschkovarianzmatrix")]
-pub trait ProcessNoiseCovarianceMatrix<const CONTROLS: usize, T = f32>:
+pub trait DirectProcessNoiseCovarianceMatrix<const STATES: usize, T = f32>:
+    RowMajorSequentialData<STATES, STATES, T> + Index<usize, Output = T>
+{
+    type Target: Matrix<STATES, STATES, T>;
+
+    fn as_matrix(&self) -> &Self::Target;
+}
+
+/// Process noise covariance matrix. Represents the uncertainty in the state transition process.
+///
+/// This matrix represents the direct process noise covariance. It quantifies the
+/// uncertainty introduced by inherent system dynamics and external disturbances,
+/// providing a measure of how much the true state is expected to deviate from the
+/// predicted state due to these process variations.
+///
+/// Mutable variant. For an immutable variant, see [`DirectProcessNoiseCovarianceMatrix`].
+#[doc(alias = "ControlCovarianceMatrixMut")]
+#[doc(alias = "Prozessrauschkovarianzmatrix")]
+pub trait DirectProcessNoiseCovarianceMatrixMut<const STATES: usize, T = f32>:
+    DirectProcessNoiseCovarianceMatrix<STATES, T>
+    + RowMajorSequentialDataMut<STATES, STATES, T>
+    + IndexMut<usize, Output = T>
+{
+    type TargetMut: MatrixMut<STATES, STATES, T>;
+
+    fn as_matrix_mut(&mut self) -> &mut Self::TargetMut;
+}
+
+/// Process noise covariance matrix. Represents the uncertainty in the state transition process.
+///
+/// This matrix represents the control process noise covariance. It quantifies the
+/// uncertainty introduced by the control inputs, reflecting how much the true state
+/// is expected to deviate from the predicted state due to noise and variations
+/// in the control process. The matrix is calculated as B×Q×Bᵀ, where B
+/// represents the control input model, and Q is the process noise covariance (this matrix).
+///
+/// Immutable variant. For a mutable variant, see [`ControlProcessNoiseCovarianceMatrixMut`].
+#[doc(alias = "ControlCovarianceMatrix")]
+#[doc(alias = "Prozessrauschkovarianzmatrix")]
+pub trait ControlProcessNoiseCovarianceMatrix<const CONTROLS: usize, T = f32>:
     RowMajorSequentialData<CONTROLS, CONTROLS, T> + Index<usize, Output = T>
 {
     type Target: Matrix<CONTROLS, CONTROLS, T>;
@@ -135,11 +179,17 @@ pub trait ProcessNoiseCovarianceMatrix<const CONTROLS: usize, T = f32>:
 
 /// Process noise covariance matrix. Represents the uncertainty in the state transition process.
 ///
-/// Mutable variant. For an immutable variant, see [`ProcessNoiseCovarianceMatrix`].
+/// This matrix represents the control process noise covariance. It quantifies the
+/// uncertainty introduced by the control inputs, reflecting how much the true state
+/// is expected to deviate from the predicted state due to noise and variations
+/// in the control process. The matrix is calculated as B×Q×Bᵀ, where B
+/// represents the control input model, and Q is the process noise covariance (this matrix).
+///
+/// Mutable variant. For an immutable variant, see [`ControlProcessNoiseCovarianceMatrix`].
 #[doc(alias = "ControlCovarianceMatrixMut")]
 #[doc(alias = "Prozessrauschkovarianzmatrix")]
-pub trait ProcessNoiseCovarianceMatrixMut<const CONTROLS: usize, T = f32>:
-    ProcessNoiseCovarianceMatrix<CONTROLS, T>
+pub trait ControlProcessNoiseCovarianceMatrixMut<const CONTROLS: usize, T = f32>:
+    ControlProcessNoiseCovarianceMatrix<CONTROLS, T>
     + RowMajorSequentialDataMut<CONTROLS, CONTROLS, T>
     + IndexMut<usize, Output = T>
 {
diff --git a/crates/minikalman/src/kalman/regular.rs b/crates/minikalman/src/kalman/regular.rs
index d46c595..2ec7670 100644
--- a/crates/minikalman/src/kalman/regular.rs
+++ b/crates/minikalman/src/kalman/regular.rs
@@ -7,29 +7,27 @@ use core::marker::PhantomData;
 
 /// A builder for a [`RegularKalman`] filter instances.
 #[allow(clippy::type_complexity)]
-pub struct RegularKalmanBuilder<A, X, P, PX, TempP> {
+pub struct RegularKalmanBuilder<A, X, P, Q, PX, TempP> {
     _phantom: (
         PhantomData<A>,
         PhantomData<X>,
         PhantomData<P>,
+        PhantomData<Q>,
         PhantomData<PX>,
         PhantomData<TempP>,
     ),
 }
 
-impl<A, X, P, PX, TempP> RegularKalmanBuilder<A, X, P, PX, TempP> {
+impl<A, X, P, Q, PX, TempP> RegularKalmanBuilder<A, X, P, Q, PX, TempP> {
     /// Initializes a Kalman filter instance.
     ///
     /// ## Arguments
-    /// * `A` - The state transition matrix (`STATES` × `STATES`), or the Jacobian in an EKF.
+    /// * `A` - The state transition matrix (`STATES` × `STATES`).
     /// * `x` - The state vector (`STATES` × `1`).
-    /// * `B` - The control transition matrix (`STATES` × `CONTROLS`).
-    /// * `u` - The control vector (`CONTROLS` × `1`).
     /// * `P` - The state covariance matrix (`STATES` × `STATES`).
-    /// * `Q` - The control covariance matrix (`CONTROLS` × `CONTROLS`).
+    /// * `Q` - The direct process noise matrix (`STATES` × `STATES`).
     /// * `predictedX` - The temporary vector for predicted states (`STATES` × `1`).
     /// * `temp_P` - The temporary vector for P calculation (`STATES` × `STATES`).
-    /// * `temp_BQ` - The temporary vector for B×Q calculation (`STATES` × `CONTROLS`).
     ///
     /// ## Example
     ///
@@ -44,6 +42,7 @@ impl<A, X, P, PX, TempP> RegularKalmanBuilder<A, X, P, PX, TempP> {
     /// impl_buffer_x!(mut gravity_x, NUM_STATES, f32, 0.0);
     /// impl_buffer_A!(mut gravity_A, NUM_STATES, f32, 0.0);
     /// impl_buffer_P!(mut gravity_P, NUM_STATES, f32, 0.0);
+    /// impl_buffer_Q_direct!(mut gravity_Q, NUM_STATES, f32, 0.0);
     ///
     /// // Filter temporaries.
     /// impl_buffer_temp_x!(mut gravity_temp_x, NUM_STATES, f32, 0.0);
@@ -53,6 +52,7 @@ impl<A, X, P, PX, TempP> RegularKalmanBuilder<A, X, P, PX, TempP> {
     ///     gravity_A,
     ///     gravity_x,
     ///     gravity_P,
+    ///     gravity_Q,
     ///     gravity_temp_x,
     ///     gravity_temp_P,
     ///  );
@@ -62,21 +62,24 @@ impl<A, X, P, PX, TempP> RegularKalmanBuilder<A, X, P, PX, TempP> {
         A: A,
         x: X,
         P: P,
+        Q: Q,
         predicted_x: PX,
         temp_P: TempP,
-    ) -> RegularKalman<STATES, T, A, X, P, PX, TempP>
+    ) -> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
     where
         T: MatrixDataType,
         A: StateTransitionMatrix<STATES, T>,
         X: StateVectorMut<STATES, T>,
         P: EstimateCovarianceMatrix<STATES, T>,
+        Q: DirectProcessNoiseCovarianceMatrix<STATES, T>,
         PX: PredictedStateEstimateVector<STATES, T>,
         TempP: TemporaryStateMatrix<STATES, T>,
     {
-        RegularKalman::<STATES, T, _, _, _, _, _> {
+        RegularKalman::<STATES, T, _, _, _, _, _, _> {
             x,
             A,
             P,
+            Q,
             predicted_x,
             temp_P,
             _phantom: Default::default(),
@@ -86,7 +89,7 @@ impl<A, X, P, PX, TempP> RegularKalmanBuilder<A, X, P, PX, TempP> {
 
 /// Kalman Filter structure.  See [`RegularKalmanBuilder`] for construction.
 #[allow(non_snake_case, unused)]
-pub struct RegularKalman<const STATES: usize, T, A, X, P, PX, TempP> {
+pub struct RegularKalman<const STATES: usize, T, A, X, P, Q, PX, TempP> {
     /// State vector.
     x: X,
 
@@ -95,11 +98,16 @@ pub struct RegularKalman<const STATES: usize, T, A, X, P, PX, TempP> {
     /// See also [`P`].
     A: A,
 
-    /// System covariance matrix.
+    /// Estimation covariance matrix.
     ///
     /// See also [`A`].
     P: P,
 
+    /// Direct process noise matrix.
+    ///
+    /// See also [`P`].
+    Q: Q,
+
     /// x-sized temporary vector.
     predicted_x: PX,
 
@@ -111,14 +119,16 @@ pub struct RegularKalman<const STATES: usize, T, A, X, P, PX, TempP> {
     _phantom: PhantomData<T>,
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP> {
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP>
+    RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
+{
     /// Returns the number of states.
     pub const fn states(&self) -> usize {
         STATES
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVector<STATES, T>,
 {
@@ -132,7 +142,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
 {
@@ -147,7 +157,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrix<STATES, T>,
 {
@@ -165,7 +175,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrixMut<STATES, T>,
 {
@@ -183,7 +193,7 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -209,7 +219,9 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X, P, PX, TempP> {
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP>
+    RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
+{
     /// Performs the time update / prediction step.
     ///
     /// This call assumes that the control covariance and variables are already set in the filter structure.
@@ -571,13 +583,13 @@ impl<const STATES: usize, T, A, X, P, PX, TempP> RegularKalman<STATES, T, A, X,
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterNumStates<STATES>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterNumStates<STATES>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 {
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateVector<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateVector<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVector<STATES, T>,
 {
@@ -589,8 +601,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateVectorMut<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateVectorMut<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
 {
@@ -602,8 +614,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateTransition<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateTransition<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrix<STATES, T>,
 {
@@ -615,8 +627,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterStateTransitionMut<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterStateTransitionMut<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     A: StateTransitionMatrixMut<STATES, T>,
 {
@@ -628,8 +640,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterEstimateCovariance<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterEstimateCovariance<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -641,8 +653,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterEstimateCovarianceMut<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterEstimateCovarianceMut<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
 {
@@ -654,8 +666,40 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterPredict<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
+where
+    P: DirectProcessNoiseCovarianceMatrix<STATES, T>,
+{
+    /// Gets a reference to the direct process noise matrix Q.
+    ///
+    /// This matrix represents the process noise covariance. It quantifies the uncertainty
+    /// introduced by the model dynamics and process variations, providing a measure of
+    /// how much the true state is expected to deviate from the predicted state due to
+    /// inherent system noise and external influences.
+    #[inline(always)]
+    pub fn direct_process_noise(&self) -> &Q {
+        &self.Q
+    }
+}
+
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
+where
+    P: DirectProcessNoiseCovarianceMatrixMut<STATES, T>,
+{
+    /// Gets a mutable reference to the direct process noise matrix Q.
+    ///
+    /// This matrix represents the process noise covariance. It quantifies the uncertainty
+    /// introduced by the model dynamics and process variations, providing a measure of
+    /// how much the true state is expected to deviate from the predicted state due to
+    /// inherent system noise and external influences.
+    #[inline(always)]
+    pub fn direct_process_noise_mut(&mut self) -> &mut Q {
+        &mut self.Q
+    }
+}
+
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterPredict<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     X: StateVectorMut<STATES, T>,
     A: StateTransitionMatrix<STATES, T>,
@@ -670,8 +714,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterUpdate<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterUpdate<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
     X: StateVectorMut<STATES, T>,
@@ -686,8 +730,8 @@ where
     }
 }
 
-impl<const STATES: usize, T, A, X, P, PX, TempP> KalmanFilterApplyControl<STATES, T>
-    for RegularKalman<STATES, T, A, X, P, PX, TempP>
+impl<const STATES: usize, T, A, X, P, Q, PX, TempP> KalmanFilterApplyControl<STATES, T>
+    for RegularKalman<STATES, T, A, X, P, Q, PX, TempP>
 where
     P: EstimateCovarianceMatrix<STATES, T>,
     X: StateVectorMut<STATES, T>,
diff --git a/crates/minikalman/src/kalman_builder/extended.rs b/crates/minikalman/src/kalman_builder/extended.rs
index 0575d49..7569270 100644
--- a/crates/minikalman/src/kalman_builder/extended.rs
+++ b/crates/minikalman/src/kalman_builder/extended.rs
@@ -30,6 +30,7 @@ pub type KalmanFilterType<const STATES: usize, T> = ExtendedKalman<
     SystemMatrixMutBufferOwnedType<STATES, T>,
     StateVectorBufferOwnedType<STATES, T>,
     EstimateCovarianceMatrixBufferOwnedType<STATES, T>,
+    DirectProcessNoiseCovarianceMatrixBufferOwnedType<STATES, T>,
     TemporaryStatePredictionVectorBufferOwnedType<STATES, T>,
     TemporaryStateMatrixBufferOwnedType<STATES, T>,
 >;
@@ -64,6 +65,7 @@ impl<const STATES: usize, T> KalmanFilterBuilder<STATES, T> {
         let state_vector = BufferBuilder::state_vector_x::<STATES>().new();
         let system_matrix = BufferBuilder::system_matrix_A::<STATES>().new();
         let system_covariance = BufferBuilder::estimate_covariance_P::<STATES>().new();
+        let process_noise = BufferBuilder::direct_process_noise_covariance_Q::<STATES>().new();
 
         // Filter temporaries.
         let temp_x = BufferBuilder::state_prediction_temp_x::<STATES>().new();
@@ -73,6 +75,7 @@ impl<const STATES: usize, T> KalmanFilterBuilder<STATES, T> {
             system_matrix,
             state_vector,
             system_covariance,
+            process_noise,
             temp_x,
             temp_p,
         )
diff --git a/crates/minikalman/src/kalman_builder/regular.rs b/crates/minikalman/src/kalman_builder/regular.rs
index d7c0035..ee3d6d4 100644
--- a/crates/minikalman/src/kalman_builder/regular.rs
+++ b/crates/minikalman/src/kalman_builder/regular.rs
@@ -36,6 +36,7 @@ pub type KalmanFilterType<const STATES: usize, T> = RegularKalman<
     SystemMatrixMutBufferOwnedType<STATES, T>,
     StateVectorBufferOwnedType<STATES, T>,
     EstimateCovarianceMatrixBufferOwnedType<STATES, T>,
+    DirectProcessNoiseCovarianceMatrixBufferOwnedType<STATES, T>,
     TemporaryStatePredictionVectorBufferOwnedType<STATES, T>,
     TemporaryStateMatrixBufferOwnedType<STATES, T>,
 >;
@@ -71,6 +72,7 @@ impl<const STATES: usize, T> KalmanFilterBuilder<STATES, T> {
         let state_vector = BufferBuilder::state_vector_x::<STATES>().new();
         let system_matrix = BufferBuilder::system_matrix_A::<STATES>().new();
         let system_covariance = BufferBuilder::estimate_covariance_P::<STATES>().new();
+        let process_noise = BufferBuilder::direct_process_noise_covariance_Q::<STATES>().new();
 
         // Filter temporaries.
         let temp_x = BufferBuilder::state_prediction_temp_x::<STATES>().new();
@@ -80,6 +82,7 @@ impl<const STATES: usize, T> KalmanFilterBuilder<STATES, T> {
             system_matrix,
             state_vector,
             system_covariance,
+            process_noise,
             temp_x,
             temp_p,
         )
@@ -111,7 +114,7 @@ pub type KalmanFilterControlType<const STATES: usize, const CONTROLS: usize, T>
     T,
     ControlMatrixBufferOwnedType<STATES, CONTROLS, T>,
     ControlVectorBufferOwnedType<CONTROLS, T>,
-    ControlCovarianceMatrixBufferOwnedType<CONTROLS, T>,
+    ControlProcessNoiseCovarianceMatrixBufferOwnedType<CONTROLS, T>,
     TemporaryBQMatrixBufferOwnedType<STATES, CONTROLS, T>,
 >;
 
@@ -143,7 +146,8 @@ impl<const STATES: usize, T> KalmanFilterControlBuilder<STATES, T> {
         // Control buffers.
         let control_vector = BufferBuilder::control_vector_u::<CONTROLS>().new();
         let control_matrix = BufferBuilder::control_matrix_B::<STATES, CONTROLS>().new();
-        let control_covariance = BufferBuilder::process_noise_covariance_Q::<CONTROLS>().new();
+        let control_covariance =
+            BufferBuilder::control_process_noise_covariance_Q::<CONTROLS>().new();
 
         // Control temporaries.
         let temp_bq = BufferBuilder::temp_BQ::<STATES, CONTROLS>().new();
diff --git a/crates/minikalman/src/lib.rs b/crates/minikalman/src/lib.rs
index e851dbd..4258c89 100644
--- a/crates/minikalman/src/lib.rs
+++ b/crates/minikalman/src/lib.rs
@@ -140,9 +140,10 @@
 //! impl_buffer_x!(static mut gravity_x, NUM_STATES, f32, 0.0);
 //! impl_buffer_A!(static mut gravity_A, NUM_STATES, f32, 0.0);
 //! impl_buffer_P!(static mut gravity_P, NUM_STATES, f32, 0.0);
+//! impl_buffer_Q_direct!(static mut gravity_Q, NUM_STATES, f32, 0.0);
 //!
 //! // Observation buffers.
-//! impl_buffer_Q!(static mut gravity_z, NUM_OBSERVATIONS, f32, 0.0);
+//! impl_buffer_z!(static mut gravity_z, NUM_OBSERVATIONS, f32, 0.0);
 //! impl_buffer_H!(static mut gravity_H, NUM_OBSERVATIONS, NUM_STATES, f32, 0.0);
 //! impl_buffer_R!(static mut gravity_R, NUM_OBSERVATIONS, f32, 0.0);
 //! impl_buffer_y!(static mut gravity_y, NUM_OBSERVATIONS, f32, 0.0);
@@ -165,6 +166,7 @@
 //!     StateTransitionMatrixMutBuffer::from(unsafe { gravity_A.as_mut_slice() }),
 //!     StateVectorBuffer::from(unsafe { gravity_x.as_mut_slice() }),
 //!     EstimateCovarianceMatrixBuffer::from(unsafe { gravity_P.as_mut_slice() }),
+//!     DirectProcessNoiseCovarianceMatrixBuffer::from(unsafe { gravity_Q.as_mut_slice() }),
 //!     PredictedStateEstimateVectorBuffer::from(unsafe { gravity_temp_x.as_mut_slice() }),
 //!     TemporaryStateMatrixBuffer::from(unsafe { gravity_temp_P.as_mut_slice() }),
 //! );
@@ -256,10 +258,11 @@ pub mod prelude {
     pub use crate::matrix::*;
 
     pub use crate::{
-        impl_buffer_A, impl_buffer_B, impl_buffer_H, impl_buffer_K, impl_buffer_P, impl_buffer_Q,
-        impl_buffer_R, impl_buffer_S, impl_buffer_temp_BQ, impl_buffer_temp_HP,
-        impl_buffer_temp_KHP, impl_buffer_temp_P, impl_buffer_temp_PHt, impl_buffer_temp_S_inv,
-        impl_buffer_temp_x, impl_buffer_u, impl_buffer_x, impl_buffer_y, impl_buffer_z,
+        impl_buffer_A, impl_buffer_B, impl_buffer_H, impl_buffer_K, impl_buffer_P,
+        impl_buffer_Q_control, impl_buffer_Q_direct, impl_buffer_R, impl_buffer_S,
+        impl_buffer_temp_BQ, impl_buffer_temp_HP, impl_buffer_temp_KHP, impl_buffer_temp_P,
+        impl_buffer_temp_PHt, impl_buffer_temp_S_inv, impl_buffer_temp_x, impl_buffer_u,
+        impl_buffer_x, impl_buffer_y, impl_buffer_z,
     };
 
     pub use crate::{
diff --git a/crates/minikalman/src/static_macros.rs b/crates/minikalman/src/static_macros.rs
index 1544a90..2fcc7d5 100644
--- a/crates/minikalman/src/static_macros.rs
+++ b/crates/minikalman/src/static_macros.rs
@@ -319,9 +319,9 @@ macro_rules! impl_buffer_B {
     };
 }
 
-/// Creates a static buffer fitting the square process noise covariance matrix Q (`num_controls` × `num_controls`).
+/// Creates a static buffer fitting the square control process noise covariance matrix Q (`num_controls` × `num_controls`).
 ///
-/// This will create a [`ProcessNoiseCovarianceMatrixMutBuffer`](crate::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer)
+/// This will create a [`ProcessNoiseCovarianceMatrixMutBuffer`](crate::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer)
 /// backed by a [`MatrixDataArray`](crate::matrix::MatrixDataArray).
 ///
 /// ## Arguments
@@ -335,7 +335,7 @@ macro_rules! impl_buffer_B {
 /// ```
 /// # use minikalman::prelude::*;
 /// const NUM_CONTROLS: usize = 2;
-/// impl_buffer_Q!(static mut Q, NUM_CONTROLS, f32, 0.0);
+/// impl_buffer_Q_control!(static mut Q, NUM_CONTROLS, f32, 0.0);
 ///
 /// unsafe {
 ///     assert_eq!(Q.len(), 4);
@@ -344,31 +344,31 @@ macro_rules! impl_buffer_B {
 /// ```
 #[macro_export]
 #[allow(non_snake_case)]
-macro_rules! impl_buffer_Q {
+macro_rules! impl_buffer_Q_control {
     (mut $mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, let mut)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, let mut)
     };
     ($mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, let)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, let)
     };
     (let mut $mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, let mut)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, let mut)
     };
     (let $mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, let)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, let)
     };
     (static mut $mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, static mut)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, static mut)
     };
     (static $mat_name:ident, $num_controls:expr, $t:ty, $init:expr) => {
-        $crate::impl_buffer_Q!($mat_name, $num_controls, $t, $init, static)
+        $crate::impl_buffer_Q_control!($mat_name, $num_controls, $t, $init, static)
     };
     ($mat_name:ident, $num_controls:expr, $t:ty, $init:expr, $($keywords:tt)+) => {
-        $($keywords)* $mat_name: $crate::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer<
+        $($keywords)* $mat_name: $crate::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer<
             $num_controls,
             $t,
             $crate::matrix::MatrixDataArray<$num_controls, $num_controls, { $num_controls * $num_controls }, $t>,
-        > = $crate::buffers::types::ProcessNoiseCovarianceMatrixMutBuffer::<
+        > = $crate::buffers::types::ControlProcessNoiseCovarianceMatrixMutBuffer::<
             $num_controls,
             $t,
             $crate::matrix::MatrixDataArray<$num_controls, $num_controls, { $num_controls * $num_controls }, $t>,
@@ -378,6 +378,65 @@ macro_rules! impl_buffer_Q {
     };
 }
 
+/// Creates a static buffer fitting the square direct process noise covariance matrix Q (`num_states` × `num_states`).
+///
+/// This will create a [`DirectProcessNoiseCovarianceMatrixMutBuffer`](crate::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer)
+/// backed by a [`MatrixDataArray`](crate::matrix::MatrixDataArray).
+///
+/// ## Arguments
+/// * `num_controls` - The number of controls to the system.
+/// * `t` - The data type.
+/// * `init` - The default value to initialize the buffer with.
+///
+/// ## Example
+/// You can generate a `static mut` binding:
+///
+/// ```
+/// # use minikalman::prelude::*;
+/// const NUM_CONTROLS: usize = 2;
+/// impl_buffer_Q_direct!(static mut Q, NUM_CONTROLS, f32, 0.0);
+///
+/// unsafe {
+///     assert_eq!(Q.len(), 4);
+///     assert_eq!(Q[0], 0.0_f32);
+/// }
+/// ```
+#[macro_export]
+#[allow(non_snake_case)]
+macro_rules! impl_buffer_Q_direct {
+    (mut $mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, let mut)
+    };
+    ($mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, let)
+    };
+    (let mut $mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, let mut)
+    };
+    (let $mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, let)
+    };
+    (static mut $mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, static mut)
+    };
+    (static $mat_name:ident, $num_states:expr, $t:ty, $init:expr) => {
+        $crate::impl_buffer_Q_direct!($mat_name, $num_states, $t, $init, static)
+    };
+    ($mat_name:ident, $num_states:expr, $t:ty, $init:expr, $($keywords:tt)+) => {
+        $($keywords)* $mat_name: $crate::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer<
+            $num_states,
+            $t,
+            $crate::matrix::MatrixDataArray<$num_states, $num_states, { $num_states * $num_states }, $t>,
+        > = $crate::buffers::types::DirectProcessNoiseCovarianceMatrixMutBuffer::<
+            $num_states,
+            $t,
+            $crate::matrix::MatrixDataArray<$num_states, $num_states, { $num_states * $num_states }, $t>,
+        >::new($crate::matrix::MatrixDataArray::new_unchecked(
+            [$init; { $num_states * $num_states }],
+        ));
+    };
+}
+
 /// Creates a static buffer fitting the measurement vector z (`num_measurements` × `1`).
 ///
 /// This will create a [`ObservationVectorBuffer`](crate::buffers::types::MeasurementVectorBuffer)
diff --git a/crates/minikalman/src/test_dummies.rs b/crates/minikalman/src/test_dummies.rs
index 9748091..4b009e7 100644
--- a/crates/minikalman/src/test_dummies.rs
+++ b/crates/minikalman/src/test_dummies.rs
@@ -17,6 +17,7 @@ pub fn make_dummy_filter() -> RegularKalman<
     Dummy<f32, 3, 3>,
     Dummy<f32, 3, 1>,
     Dummy<f32, 3, 3>,
+    Dummy<f32, 3, 3>,
     Dummy<f32, 3, 1>,
     Dummy<f32, 3, 3>,
 > {
@@ -26,6 +27,7 @@ pub fn make_dummy_filter() -> RegularKalman<
         Dummy::default(),
         Dummy::default(),
         Dummy::default(),
+        Dummy::default(),
     )
 }
 
@@ -35,6 +37,7 @@ pub fn make_dummy_filter_ekf() -> ExtendedKalman<
     Dummy<f32, 3, 3>,
     Dummy<f32, 3, 1>,
     Dummy<f32, 3, 3>,
+    Dummy<f32, 3, 3>,
     Dummy<f32, 3, 1>,
     Dummy<f32, 3, 3>,
 > {
@@ -44,6 +47,7 @@ pub fn make_dummy_filter_ekf() -> ExtendedKalman<
         Dummy::default(),
         Dummy::default(),
         Dummy::default(),
+        Dummy::default(),
     )
 }
 
@@ -263,7 +267,27 @@ impl<const STATES: usize, const CONTROLS: usize, T> ControlMatrixMut<STATES, CON
     }
 }
 
-impl<const CONTROLS: usize, T> ProcessNoiseCovarianceMatrix<CONTROLS, T>
+impl<const STATES: usize, T> DirectProcessNoiseCovarianceMatrix<STATES, T>
+    for Dummy<T, STATES, STATES>
+{
+    type Target = DummyMatrix<T, STATES, STATES>;
+
+    fn as_matrix(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const STATES: usize, T> DirectProcessNoiseCovarianceMatrixMut<STATES, T>
+    for Dummy<T, STATES, STATES>
+{
+    type TargetMut = DummyMatrix<T, STATES, STATES>;
+
+    fn as_matrix_mut(&mut self) -> &mut Self::TargetMut {
+        &mut self.0
+    }
+}
+
+impl<const CONTROLS: usize, T> ControlProcessNoiseCovarianceMatrix<CONTROLS, T>
     for Dummy<T, CONTROLS, CONTROLS>
 {
     type Target = DummyMatrix<T, CONTROLS, CONTROLS>;
@@ -273,7 +297,7 @@ impl<const CONTROLS: usize, T> ProcessNoiseCovarianceMatrix<CONTROLS, T>
     }
 }
 
-impl<const CONTROLS: usize, T> ProcessNoiseCovarianceMatrixMut<CONTROLS, T>
+impl<const CONTROLS: usize, T> ControlProcessNoiseCovarianceMatrixMut<CONTROLS, T>
     for Dummy<T, CONTROLS, CONTROLS>
 {
     type TargetMut = DummyMatrix<T, CONTROLS, CONTROLS>;
diff --git a/crates/minikalman/tests/gravity.rs b/crates/minikalman/tests/gravity.rs
index b5b91ca..b1a01a9 100644
--- a/crates/minikalman/tests/gravity.rs
+++ b/crates/minikalman/tests/gravity.rs
@@ -41,6 +41,7 @@ fn test_gravity_estimation() {
     impl_buffer_x!(mut gravity_x, NUM_STATES, f32, 0.0);
     impl_buffer_A!(mut gravity_A, NUM_STATES, f32, 0.0);
     impl_buffer_P!(mut gravity_P, NUM_STATES, f32, 0.0);
+    impl_buffer_Q_direct!(mut gravity_Q, NUM_STATES, f32, 0.0);
 
     // Observation buffers.
     impl_buffer_z!(mut gravity_z, NUM_OBSERVATIONS, f32, 0.0);
@@ -64,6 +65,7 @@ fn test_gravity_estimation() {
         gravity_A,
         gravity_x,
         gravity_P,
+        gravity_Q,
         gravity_temp_x,
         gravity_temp_P,
     );
diff --git a/crates/minikalman/tests/gravity_q_tuned.rs b/crates/minikalman/tests/gravity_q_tuned.rs
index 0fb090b..d6e1423 100644
--- a/crates/minikalman/tests/gravity_q_tuned.rs
+++ b/crates/minikalman/tests/gravity_q_tuned.rs
@@ -5,6 +5,7 @@
 
 #![forbid(unsafe_code)]
 
+use minikalman::impl_buffer_Q_direct;
 use minikalman::prelude::*;
 use minikalman::regular::{RegularKalmanBuilder, RegularObservationBuilder};
 
@@ -41,6 +42,7 @@ fn test_gravity_estimation_tuned() {
     impl_buffer_x!(mut gravity_x, NUM_STATES, f64, 0.0);
     impl_buffer_A!(mut gravity_A, NUM_STATES, f64, 0.0);
     impl_buffer_P!(mut gravity_P, NUM_STATES, f64, 0.0);
+    impl_buffer_Q_direct!(mut gravity_Q, NUM_STATES, f64, 0.0);
 
     // Observation buffers.
     impl_buffer_z!(mut gravity_z, NUM_OBSERVATIONS, f64, 0.0);
@@ -64,6 +66,7 @@ fn test_gravity_estimation_tuned() {
         gravity_A,
         gravity_x,
         gravity_P,
+        gravity_Q,
         gravity_temp_x,
         gravity_temp_P,
     );
diff --git a/xbuild-tests/stm32/src/kalman_fixed_example.rs b/xbuild-tests/stm32/src/kalman_fixed_example.rs
index 0e5860f..a069c99 100644
--- a/xbuild-tests/stm32/src/kalman_fixed_example.rs
+++ b/xbuild-tests/stm32/src/kalman_fixed_example.rs
@@ -67,9 +67,10 @@ pub fn predict_gravity() -> I16F16 {
     impl_buffer_x!(static mut gravity_x, NUM_STATES, I16F16, I16F16::ZERO);
     impl_buffer_A!(static mut gravity_A, NUM_STATES, I16F16, I16F16::ZERO);
     impl_buffer_P!(static mut gravity_P, NUM_STATES, I16F16, I16F16::ZERO);
+    impl_buffer_Q_direct!(static mut gravity_Q, NUM_STATES, I16F16, I16F16::ZERO);
 
     // Observation buffers.
-    impl_buffer_Q!(static mut gravity_z, NUM_OBSERVATIONS, I16F16, I16F16::ZERO);
+    impl_buffer_Q_control!(static mut gravity_z, NUM_OBSERVATIONS, I16F16, I16F16::ZERO);
     impl_buffer_H!(
         static mut gravity_H,
         NUM_OBSERVATIONS,
@@ -121,6 +122,7 @@ pub fn predict_gravity() -> I16F16 {
         StateTransitionMatrixMutBuffer::from(unsafe { gravity_A.as_mut_slice() }),
         StateVectorBuffer::from(unsafe { gravity_x.as_mut_slice() }),
         EstimateCovarianceMatrixBuffer::from(unsafe { gravity_P.as_mut_slice() }),
+        DirectProcessNoiseCovarianceMatrixBuffer::from(unsafe { gravity_Q.as_mut_slice() }),
         PredictedStateEstimateVectorBuffer::from(unsafe { gravity_temp_x.as_mut_slice() }),
         TemporaryStateMatrixBuffer::from(unsafe { gravity_temp_P.as_mut_slice() }),
     );
diff --git a/xbuild-tests/stm32/src/kalman_float_example.rs b/xbuild-tests/stm32/src/kalman_float_example.rs
index f2b2ab2..9a7fd5f 100644
--- a/xbuild-tests/stm32/src/kalman_float_example.rs
+++ b/xbuild-tests/stm32/src/kalman_float_example.rs
@@ -36,9 +36,10 @@ pub fn predict_gravity() -> f32 {
     impl_buffer_x!(static mut gravity_x, NUM_STATES, f32, 0.0);
     impl_buffer_A!(static mut gravity_A, NUM_STATES, f32, 0.0);
     impl_buffer_P!(static mut gravity_P, NUM_STATES, f32, 0.0);
+    impl_buffer_Q_direct!(static mut gravity_Q, NUM_STATES, f32, 0.0);
 
     // Observation buffers.
-    impl_buffer_Q!(static mut gravity_z, NUM_OBSERVATIONS, f32, 0.0);
+    impl_buffer_z!(static mut gravity_z, NUM_OBSERVATIONS, f32, 0.0);
     impl_buffer_H!(static mut gravity_H, NUM_OBSERVATIONS, NUM_STATES, f32, 0.0);
     impl_buffer_R!(static mut gravity_R, NUM_OBSERVATIONS, f32, 0.0);
     impl_buffer_y!(static mut gravity_y, NUM_OBSERVATIONS, f32, 0.0);
@@ -61,6 +62,7 @@ pub fn predict_gravity() -> f32 {
         StateTransitionMatrixMutBuffer::from(unsafe { gravity_A.as_mut_slice() }),
         StateVectorBuffer::from(unsafe { gravity_x.as_mut_slice() }),
         EstimateCovarianceMatrixBuffer::from(unsafe { gravity_P.as_mut_slice() }),
+        DirectProcessNoiseCovarianceMatrixBuffer::from(unsafe { gravity_Q.as_mut_slice() }),
         PredictedStateEstimateVectorBuffer::from(unsafe { gravity_temp_x.as_mut_slice() }),
         TemporaryStateMatrixBuffer::from(unsafe { gravity_temp_P.as_mut_slice() }),
     );