diff --git a/dasp_graph/src/buffer.rs b/dasp_graph/src/buffer.rs
index aed0a7b6..588c113e 100644
--- a/dasp_graph/src/buffer.rs
+++ b/dasp_graph/src/buffer.rs
@@ -3,17 +3,14 @@ use core::ops::{Deref, DerefMut};
 
 /// The fixed-size buffer used for processing the graph.
 #[derive(Clone)]
-pub struct Buffer {
-    data: [f32; Self::LEN],
+pub struct Buffer<const N: usize> {
+    data: [f32; N],
 }
 
-impl Buffer {
-    /// The fixed length of the **Buffer** type.
-    pub const LEN: usize = 64;
+impl<const N: usize> Buffer<N> {
+    pub const LEN: usize = N;
     /// A silent **Buffer**.
-    pub const SILENT: Self = Buffer {
-        data: [0.0; Self::LEN],
-    };
+    pub const SILENT: Self = Buffer { data: [0.0; N] };
 
     /// Short-hand for writing silence to the whole buffer.
     pub fn silence(&mut self) {
@@ -21,38 +18,38 @@ impl Buffer {
     }
 }
 
-impl Default for Buffer {
+impl<const N: usize> Default for Buffer<N> {
     fn default() -> Self {
         Self::SILENT
     }
 }
 
-impl From<[f32; Self::LEN]> for Buffer {
-    fn from(data: [f32; Self::LEN]) -> Self {
+impl<const N: usize> From<[f32; N]> for Buffer<N> {
+    fn from(data: [f32; N]) -> Self {
         Buffer { data }
     }
 }
 
-impl fmt::Debug for Buffer {
+impl<const N: usize> fmt::Debug for Buffer<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&self.data[..], f)
     }
 }
 
-impl PartialEq for Buffer {
+impl<const N: usize> PartialEq for Buffer<N> {
     fn eq(&self, other: &Self) -> bool {
         &self[..] == &other[..]
     }
 }
 
-impl Deref for Buffer {
+impl<const N: usize> Deref for Buffer<N> {
     type Target = [f32];
     fn deref(&self) -> &Self::Target {
         &self.data[..]
     }
 }
 
-impl DerefMut for Buffer {
+impl<const N: usize> DerefMut for Buffer<N> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.data[..]
     }
diff --git a/dasp_graph/src/lib.rs b/dasp_graph/src/lib.rs
index 2dcb145e..925d884b 100644
--- a/dasp_graph/src/lib.rs
+++ b/dasp_graph/src/lib.rs
@@ -152,16 +152,16 @@ pub mod node;
 /// use petgraph;
 /// #
 /// # // The node type. (Hint: Use existing node impls by enabling their associated features).
-/// # struct MyNode;
+/// # struct MyNode<const N: usize>;
 ///
 /// // Chose a type of graph for audio processing.
-/// type Graph = petgraph::graph::DiGraph<NodeData<MyNode>, (), u32>;
+/// type Graph = petgraph::graph::DiGraph<NodeData<MyNode::<128>, 128>, (), u32>;
 /// // Create a short-hand for our processor type.
-/// type Processor = dasp_graph::Processor<Graph>;
+/// type Processor = dasp_graph::Processor<Graph, 128>;
 /// #
-/// # impl Node for MyNode {
+/// # impl<const N: usize> Node<N> for MyNode<N> {
 /// #     // ...
-/// #    fn process(&mut self, _inputs: &[Input], _output: &mut [Buffer]) {
+/// #    fn process(&mut self, _inputs: &[Input<N>], _output: &mut [Buffer<N>]) {
 /// #    }
 /// # }
 ///
@@ -173,37 +173,37 @@ pub mod node;
 ///     let mut p = Processor::with_capacity(max_nodes);
 ///
 ///     // Add some nodes and edges...
-/// #    let n_id = g.add_node(NodeData::new1(MyNode));
+/// #    let n_id = g.add_node(NodeData::new1(MyNode::<128>));
 ///
 ///     // Process all nodes within the graph that output to the node at `n_id`.
 ///     p.process(&mut g, n_id);
 /// }
 /// ```
-pub struct Processor<G>
+pub struct Processor<G, const N: usize>
 where
     G: Visitable,
 {
     // State related to the traversal of the audio graph starting from the output node.
     dfs_post_order: DfsPostOrder<G::NodeId, G::Map>,
     // Solely for collecting the inputs of a node in order to apply its `Node::process` method.
-    inputs: Vec<node::Input>,
+    inputs: Vec<node::Input<N>>,
 }
 
 /// For use as the node weight within a dasp graph. Contains the node and its buffers.
 ///
 /// For a graph to be compatible with a graph **Processor**, its node weights must be of type
 /// `NodeData<T>`, where `T` is some type that implements the `Node` trait.
-pub struct NodeData<T: ?Sized> {
+pub struct NodeData<T: ?Sized, const N: usize> {
     /// The buffers to which the `node` writes audio data during a call to its `process` method.
     ///
     /// Generally, each buffer stored within `buffers` corresponds to a unique audio channel. E.g.
     /// a node processing mono data would store one buffer, a node processing stereo data would
     /// store two, and so on.
-    pub buffers: Vec<Buffer>,
+    pub buffers: Vec<Buffer<N>>,
     pub node: T,
 }
 
-impl<G> Processor<G>
+impl<G, const N: usize> Processor<G, N>
 where
     G: Visitable,
 {
@@ -242,17 +242,17 @@ where
     /// **Panics** if there is no node for the given index.
     pub fn process<T>(&mut self, graph: &mut G, node: G::NodeId)
     where
-        G: Data<NodeWeight = NodeData<T>> + DataMapMut,
+        G: Data<NodeWeight = NodeData<T, N>> + DataMapMut,
         for<'a> &'a G: GraphBase<NodeId = G::NodeId> + IntoNeighborsDirected,
-        T: Node,
+        T: Node<N>,
     {
         process(self, graph, node)
     }
 }
 
-impl<T> NodeData<T> {
+impl<T, const N: usize> NodeData<T, N> {
     /// Construct a new **NodeData** from an instance of its node type and buffers.
-    pub fn new(node: T, buffers: Vec<Buffer>) -> Self {
+    pub fn new(node: T, buffers: Vec<Buffer<N>>) -> Self {
         NodeData { node, buffers }
     }
 
@@ -268,11 +268,11 @@ impl<T> NodeData<T> {
 }
 
 #[cfg(feature = "node-boxed")]
-impl NodeData<BoxedNode> {
+impl<const N: usize> NodeData<BoxedNode<N>, N> {
     /// The same as **new**, but boxes the given node data before storing it.
-    pub fn boxed<T>(node: T, buffers: Vec<Buffer>) -> Self
+    pub fn boxed<T>(node: T, buffers: Vec<Buffer<N>>) -> Self
     where
-        T: 'static + Node,
+        T: 'static + Node<N>,
     {
         NodeData::new(BoxedNode(Box::new(node)), buffers)
     }
@@ -280,7 +280,7 @@ impl NodeData<BoxedNode> {
     /// The same as **new1**, but boxes the given node data before storing it.
     pub fn boxed1<T>(node: T) -> Self
     where
-        T: 'static + Node,
+        T: 'static + Node<N>,
     {
         Self::boxed(node, vec![Buffer::SILENT])
     }
@@ -288,7 +288,7 @@ impl NodeData<BoxedNode> {
     /// The same as **new2**, but boxes the given node data before storing it.
     pub fn boxed2<T>(node: T) -> Self
     where
-        T: 'static + Node,
+        T: 'static + Node<N>,
     {
         Self::boxed(node, vec![Buffer::SILENT, Buffer::SILENT])
     }
@@ -310,17 +310,20 @@ impl NodeData<BoxedNode> {
 /// type `NodeData<T>` where `T` implements the `Node` trait.
 ///
 /// **Panics** if there is no node for the given index.
-pub fn process<G, T>(processor: &mut Processor<G>, graph: &mut G, node: G::NodeId)
-where
-    G: Data<NodeWeight = NodeData<T>> + DataMapMut + Visitable,
+pub fn process<G, T, const N: usize>(
+    processor: &mut Processor<G, N>,
+    graph: &mut G,
+    node: G::NodeId,
+) where
+    G: Data<NodeWeight = NodeData<T, N>> + DataMapMut + Visitable,
     for<'a> &'a G: GraphBase<NodeId = G::NodeId> + IntoNeighborsDirected,
-    T: Node,
+    T: Node<N>,
 {
     const NO_NODE: &str = "no node exists for the given index";
     processor.dfs_post_order.reset(Reversed(&*graph));
     processor.dfs_post_order.move_to(node);
     while let Some(n) = processor.dfs_post_order.next(Reversed(&*graph)) {
-        let data: *mut NodeData<T> = graph.node_weight_mut(n).expect(NO_NODE) as *mut _;
+        let data: *mut NodeData<T, N> = graph.node_weight_mut(n).expect(NO_NODE) as *mut _;
         processor.inputs.clear();
         for in_n in (&*graph).neighbors_directed(n, Incoming) {
             // Skip edges that connect the node to itself to avoid aliasing `node`.
diff --git a/dasp_graph/src/node/boxed.rs b/dasp_graph/src/node/boxed.rs
index 7501d555..b5e8116f 100644
--- a/dasp_graph/src/node/boxed.rs
+++ b/dasp_graph/src/node/boxed.rs
@@ -6,7 +6,7 @@ use core::ops::{Deref, DerefMut};
 ///
 /// Provides the necessary `Sized` implementation to allow for compatibility with the graph process
 /// function.
-pub struct BoxedNode(pub Box<dyn Node>);
+pub struct BoxedNode<const N: usize>(pub Box<dyn Node<N>>);
 
 /// A wrapper around a `Box<dyn Node>`.
 ///
@@ -16,107 +16,107 @@ pub struct BoxedNode(pub Box<dyn Node>);
 /// Useful when the ability to send nodes from one thread to another is required. E.g. this is
 /// common when initialising nodes or the audio graph itself on one thread before sending them to
 /// the audio thread.
-pub struct BoxedNodeSend(pub Box<dyn Node + Send>);
+pub struct BoxedNodeSend<const N: usize>(pub Box<dyn Node<N> + Send>);
 
-impl BoxedNode {
+impl<const N: usize> BoxedNode<N> {
     /// Create a new `BoxedNode` around the given `node`.
     ///
     /// This is short-hand for `BoxedNode::from(Box::new(node))`.
     pub fn new<T>(node: T) -> Self
     where
-        T: 'static + Node,
+        T: 'static + Node<N>,
     {
         Self::from(Box::new(node))
     }
 }
 
-impl BoxedNodeSend {
+impl<const N: usize> BoxedNodeSend<N> {
     /// Create a new `BoxedNode` around the given `node`.
     ///
     /// This is short-hand for `BoxedNode::from(Box::new(node))`.
     pub fn new<T>(node: T) -> Self
     where
-        T: 'static + Node + Send,
+        T: 'static + Node<N> + Send,
     {
         Self::from(Box::new(node))
     }
 }
 
-impl Node for BoxedNode {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for BoxedNode<N> {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         self.0.process(inputs, output)
     }
 }
 
-impl Node for BoxedNodeSend {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for BoxedNodeSend<N> {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         self.0.process(inputs, output)
     }
 }
 
-impl<T> From<Box<T>> for BoxedNode
+impl<T, const N: usize> From<Box<T>> for BoxedNode<N>
 where
-    T: 'static + Node,
+    T: 'static + Node<N>,
 {
     fn from(n: Box<T>) -> Self {
-        BoxedNode(n as Box<dyn Node>)
+        BoxedNode(n as Box<dyn Node<N>>)
     }
 }
 
-impl<T> From<Box<T>> for BoxedNodeSend
+impl<T, const N: usize> From<Box<T>> for BoxedNodeSend<N>
 where
-    T: 'static + Node + Send,
+    T: 'static + Node<N> + Send,
 {
     fn from(n: Box<T>) -> Self {
-        BoxedNodeSend(n as Box<dyn Node + Send>)
+        BoxedNodeSend(n as Box<dyn Node<N> + Send>)
     }
 }
 
-impl Into<Box<dyn Node>> for BoxedNode {
-    fn into(self) -> Box<dyn Node> {
+impl<const N: usize> Into<Box<dyn Node<N>>> for BoxedNode<N> {
+    fn into(self) -> Box<dyn Node<N>> {
         self.0
     }
 }
 
-impl Into<Box<dyn Node + Send>> for BoxedNodeSend {
-    fn into(self) -> Box<dyn Node + Send> {
+impl<const N: usize> Into<Box<dyn Node<N> + Send>> for BoxedNodeSend<N> {
+    fn into(self) -> Box<dyn Node<N> + Send> {
         self.0
     }
 }
 
-impl fmt::Debug for BoxedNode {
+impl<const N: usize> fmt::Debug for BoxedNode<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("BoxedNode").finish()
     }
 }
 
-impl fmt::Debug for BoxedNodeSend {
+impl<const N: usize> fmt::Debug for BoxedNodeSend<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("BoxedNodeSend").finish()
     }
 }
 
-impl Deref for BoxedNode {
-    type Target = Box<dyn Node>;
+impl<const N: usize> Deref for BoxedNode<N> {
+    type Target = Box<dyn Node<N>>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl Deref for BoxedNodeSend {
-    type Target = Box<dyn Node + Send>;
+impl<const N: usize> Deref for BoxedNodeSend<N> {
+    type Target = Box<dyn Node<N> + Send>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl DerefMut for BoxedNode {
+impl<const N: usize> DerefMut for BoxedNode<N> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
-impl DerefMut for BoxedNodeSend {
+impl<const N: usize> DerefMut for BoxedNodeSend<N> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
diff --git a/dasp_graph/src/node/delay.rs b/dasp_graph/src/node/delay.rs
index 8e18d6b4..3ce276d5 100644
--- a/dasp_graph/src/node/delay.rs
+++ b/dasp_graph/src/node/delay.rs
@@ -9,11 +9,11 @@ use dasp_ring_buffer as ring_buffer;
 #[derive(Clone, Debug, PartialEq)]
 pub struct Delay<S>(pub Vec<ring_buffer::Fixed<S>>);
 
-impl<S> Node for Delay<S>
+impl<S, const N: usize> Node<N> for Delay<S>
 where
     S: ring_buffer::SliceMut<Element = f32>,
 {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         // Retrieve the single input, ignore any others.
         let input = match inputs.get(0) {
             Some(input) => input,
diff --git a/dasp_graph/src/node/graph.rs b/dasp_graph/src/node/graph.rs
index e4b61017..3847346a 100644
--- a/dasp_graph/src/node/graph.rs
+++ b/dasp_graph/src/node/graph.rs
@@ -7,24 +7,24 @@ use core::marker::PhantomData;
 use petgraph::data::DataMapMut;
 use petgraph::visit::{Data, GraphBase, IntoNeighborsDirected, Visitable};
 
-pub struct GraphNode<G, T>
+pub struct GraphNode<G, T, const N: usize>
 where
     G: Visitable,
 {
-    pub processor: Processor<G>,
+    pub processor: Processor<G, N>,
     pub graph: G,
     pub input_nodes: Vec<G::NodeId>,
     pub output_node: G::NodeId,
     pub node_type: PhantomData<T>,
 }
 
-impl<G, T> Node for GraphNode<G, T>
+impl<G, T, const N: usize> Node<N> for GraphNode<G, T, N>
 where
-    G: Data<NodeWeight = NodeData<T>> + DataMapMut + Visitable,
+    G: Data<NodeWeight = NodeData<T, N>> + DataMapMut + Visitable,
     for<'a> &'a G: GraphBase<NodeId = G::NodeId> + IntoNeighborsDirected,
-    T: Node,
+    T: Node<N>,
 {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         let GraphNode {
             ref mut processor,
             ref mut graph,
diff --git a/dasp_graph/src/node/mod.rs b/dasp_graph/src/node/mod.rs
index 953f6406..3a4cd529 100644
--- a/dasp_graph/src/node/mod.rs
+++ b/dasp_graph/src/node/mod.rs
@@ -46,12 +46,12 @@ mod sum;
 /// use dasp_graph::{Buffer, Input, Node};
 ///
 /// // Our new `Node` type.
-/// pub struct Sum;
+/// pub struct Sum<const N: usize>;
 ///
 /// // Implement the `Node` trait for our new type.
 /// # #[cfg(feature = "dasp_slice")]
-/// impl Node for Sum {
-///     fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+/// impl<const N: usize> Node<N> for Sum<N> {
+///     fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
 ///         // Fill the output with silence.
 ///         for out_buffer in output.iter_mut() {
 ///             out_buffer.silence();
@@ -68,7 +68,7 @@ mod sum;
 ///     }
 /// }
 /// ```
-pub trait Node {
+pub trait Node<const N: usize> {
     /// Process some audio given a list of the node's `inputs` and write the result to the `output`
     /// buffers.
     ///
@@ -82,7 +82,7 @@ pub trait Node {
     ///
     /// This `process` method is called by the [`Processor`](../struct.Processor.html) as it
     /// traverses the graph during audio rendering.
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]);
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]);
 }
 
 /// A reference to another node that is an input to the current node.
@@ -90,14 +90,14 @@ pub trait Node {
 /// *TODO: It may be useful to provide some information that can uniquely identify the input node.
 /// This could be useful to allow to distinguish between side-chained and regular inputs for
 /// example.*
-pub struct Input {
-    buffers_ptr: *const Buffer,
+pub struct Input<const N: usize> {
+    buffers_ptr: *const Buffer<N>,
     buffers_len: usize,
 }
 
-impl Input {
+impl<const N: usize> Input<N> {
     // Constructor solely for use within the graph `process` function.
-    pub(crate) fn new(slice: &[Buffer]) -> Self {
+    pub(crate) fn new(slice: &[Buffer<N>]) -> Self {
         let buffers_ptr = slice.as_ptr();
         let buffers_len = slice.len();
         Input {
@@ -107,7 +107,7 @@ impl Input {
     }
 
     /// A reference to the buffers of the input node.
-    pub fn buffers(&self) -> &[Buffer] {
+    pub fn buffers(&self) -> &[Buffer<N>] {
         // As we know that an `Input` can only be constructed during a call to the graph `process`
         // function, we can be sure that our slice is still valid as long as the input itself is
         // alive.
@@ -118,46 +118,46 @@ impl Input {
 // Inputs can only be created by the `dasp_graph::process` implementation and only ever live as
 // long as the lifetime of the call to the function. Thus, it's safe to implement this so that
 // `Send` closures can be stored within the graph and sent between threads.
-unsafe impl Send for Input {}
+unsafe impl<const N: usize> Send for Input<N> {}
 
-impl fmt::Debug for Input {
+impl<const N: usize> fmt::Debug for Input<N> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(self.buffers(), f)
     }
 }
 
-impl<'a, T> Node for &'a mut T
+impl<'a, T, const N: usize> Node<N> for &'a mut T
 where
-    T: Node,
+    T: Node<N>,
 {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         (**self).process(inputs, output)
     }
 }
 
-impl<T> Node for Box<T>
+impl<T, const N: usize> Node<N> for Box<T>
 where
-    T: Node,
+    T: Node<N>,
 {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         (**self).process(inputs, output)
     }
 }
 
-impl Node for dyn Fn(&[Input], &mut [Buffer]) {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for dyn Fn(&[Input<N>], &mut [Buffer<N>]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         (*self)(inputs, output)
     }
 }
 
-impl Node for dyn FnMut(&[Input], &mut [Buffer]) {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for dyn FnMut(&[Input<N>], &mut [Buffer<N>]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         (*self)(inputs, output)
     }
 }
 
-impl Node for fn(&[Input], &mut [Buffer]) {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for fn(&[Input<N>], &mut [Buffer<N>]) {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         (*self)(inputs, output)
     }
 }
diff --git a/dasp_graph/src/node/pass.rs b/dasp_graph/src/node/pass.rs
index 8872719a..477cac6c 100644
--- a/dasp_graph/src/node/pass.rs
+++ b/dasp_graph/src/node/pass.rs
@@ -10,8 +10,8 @@ use crate::{Buffer, Input, Node};
 #[derive(Clone, Debug, PartialEq)]
 pub struct Pass;
 
-impl Node for Pass {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for Pass {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         let input = match inputs.get(0) {
             None => return,
             Some(input) => input,
diff --git a/dasp_graph/src/node/signal.rs b/dasp_graph/src/node/signal.rs
index cd8285bc..ff427686 100644
--- a/dasp_graph/src/node/signal.rs
+++ b/dasp_graph/src/node/signal.rs
@@ -2,13 +2,13 @@ use crate::{Buffer, Input, Node};
 use dasp_frame::Frame;
 use dasp_signal::Signal;
 
-impl<F> Node for dyn Signal<Frame = F>
+impl<F, const N: usize> Node<N> for dyn Signal<Frame = F>
 where
     F: Frame<Sample = f32>,
 {
-    fn process(&mut self, _inputs: &[Input], output: &mut [Buffer]) {
+    fn process(&mut self, _inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         let channels = std::cmp::min(F::CHANNELS, output.len());
-        for ix in 0..Buffer::LEN {
+        for ix in 0..N {
             let frame = self.next();
             for ch in 0..channels {
                 // Safe, as we verify the number of channels at the beginning of the function.
diff --git a/dasp_graph/src/node/sum.rs b/dasp_graph/src/node/sum.rs
index 9a078d40..0912c970 100644
--- a/dasp_graph/src/node/sum.rs
+++ b/dasp_graph/src/node/sum.rs
@@ -22,8 +22,8 @@ pub struct Sum;
 #[derive(Clone, Debug, PartialEq)]
 pub struct SumBuffers;
 
-impl Node for Sum {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for Sum {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         // Fill the output with silence.
         for out_buffer in output.iter_mut() {
             out_buffer.silence();
@@ -40,8 +40,8 @@ impl Node for Sum {
     }
 }
 
-impl Node for SumBuffers {
-    fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+impl<const N: usize> Node<N> for SumBuffers {
+    fn process(&mut self, inputs: &[Input<N>], output: &mut [Buffer<N>]) {
         // Get the first output buffer.
         let mut out_buffers = output.iter_mut();
         let out_buffer_first = match out_buffers.next() {
diff --git a/dasp_graph/tests/graph_send.rs b/dasp_graph/tests/graph_send.rs
index 8bde1188..3459bb7f 100644
--- a/dasp_graph/tests/graph_send.rs
+++ b/dasp_graph/tests/graph_send.rs
@@ -11,8 +11,8 @@ use petgraph::visit::GraphBase;
 #[test]
 #[should_panic]
 fn test_graph_send() {
-    type Graph = petgraph::Graph<NodeData<BoxedNodeSend>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::Graph<NodeData<BoxedNodeSend<128>, 128>, (), petgraph::Directed, u32>;
+    type Processor = dasp_graph::Processor<Graph, 128>;
     let mut g: Graph = unimplemented!();
     let mut p: Processor = unimplemented!();
     let n: <Graph as GraphBase>::NodeId = unimplemented!();
diff --git a/dasp_graph/tests/graph_types.rs b/dasp_graph/tests/graph_types.rs
index a7b0212d..242e0758 100644
--- a/dasp_graph/tests/graph_types.rs
+++ b/dasp_graph/tests/graph_types.rs
@@ -11,8 +11,8 @@ use petgraph::visit::GraphBase;
 #[test]
 #[should_panic]
 fn test_graph() {
-    type Graph = petgraph::Graph<NodeData<BoxedNode>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::Graph<NodeData<BoxedNode<128>, 128>, (), petgraph::Directed, u32>;
+    type Processor = dasp_graph::Processor<Graph, 128>;
     let mut g: Graph = unimplemented!();
     let mut p: Processor = unimplemented!();
     let n: <Graph as GraphBase>::NodeId = unimplemented!();
@@ -22,9 +22,13 @@ fn test_graph() {
 #[test]
 #[should_panic]
 fn test_stable_graph() {
-    type Graph =
-        petgraph::stable_graph::StableGraph<NodeData<BoxedNode>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::stable_graph::StableGraph<
+        NodeData<BoxedNode<128>, 128>,
+        (),
+        petgraph::Directed,
+        u32,
+    >;
+    type Processor = dasp_graph::Processor<Graph, 128>;
     let mut g: Graph = unimplemented!();
     let mut p: Processor = unimplemented!();
     let n: <Graph as GraphBase>::NodeId = unimplemented!();
diff --git a/dasp_graph/tests/sum.rs b/dasp_graph/tests/sum.rs
index 4c27a69f..0e3f9b9c 100644
--- a/dasp_graph/tests/sum.rs
+++ b/dasp_graph/tests/sum.rs
@@ -2,10 +2,10 @@
 
 use dasp_graph::{node, Buffer, Input, Node, NodeData};
 
-type BoxedNode = dasp_graph::BoxedNode;
+type BoxedNode = dasp_graph::BoxedNode<128>;
 
 // A simple source node that just writes `0.1` to the output. We'll use this to test the sum node.
-fn src_node(_inputs: &[Input], output: &mut [Buffer]) {
+fn src_node(_inputs: &[Input<128>], output: &mut [Buffer<128>]) {
     for o in output {
         o.iter_mut().for_each(|s| *s = 0.1);
     }
@@ -14,8 +14,8 @@ fn src_node(_inputs: &[Input], output: &mut [Buffer]) {
 #[test]
 fn test_sum() {
     // The type of graph to use for this test.
-    type Graph = petgraph::Graph<NodeData<BoxedNode>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::Graph<NodeData<BoxedNode, 128>, (), petgraph::Directed, u32>;
+    type Processor = dasp_graph::Processor<Graph, 128>;
 
     // Create a graph and a processor.
     let max_nodes = 6;
@@ -24,7 +24,7 @@ fn test_sum() {
     let mut p = Processor::with_capacity(max_nodes);
 
     // Create and add the nodes to the graph.
-    let src_node_ptr = src_node as fn(&[Input], &mut [Buffer]);
+    let src_node_ptr = src_node as fn(&[Input<128>], &mut [Buffer<128>]);
     let src_a = g.add_node(NodeData::new1(BoxedNode::new(src_node_ptr)));
     let src_b = g.add_node(NodeData::new1(BoxedNode::new(src_node_ptr)));
     let sum = g.add_node(NodeData::new1(BoxedNode::new(node::Sum)));
@@ -37,7 +37,7 @@ fn test_sum() {
     p.process(&mut g, sum);
 
     // Check that `sum` actually contains the sum.
-    let expected = Buffer::from([0.2; Buffer::LEN]);
+    let expected = Buffer::from([0.2; 128]);
     assert_eq!(&g[sum].buffers[..], &[expected][..]);
 
     // Plug in some more sources.
@@ -50,15 +50,15 @@ fn test_sum() {
 
     // Check that the result is consistent.
     p.process(&mut g, sum);
-    let expected = Buffer::from([0.5; Buffer::LEN]);
+    let expected = Buffer::from([0.5; 128]);
     assert_eq!(&g[sum].buffers[..], &[expected][..]);
 }
 
 #[test]
 fn test_sum2() {
     // The type of graph to use for this test.
-    type Graph = petgraph::Graph<NodeData<BoxedNode>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::Graph<NodeData<BoxedNode, 128>, (), petgraph::Directed, u32>;
+    type Processor = dasp_graph::Processor<Graph, 128>;
 
     // Create a graph and a processor.
     let mut g = Graph::new();
@@ -66,7 +66,7 @@ fn test_sum2() {
 
     // Create a small tree where we first sum a and b, then sum the result with c.
     // This time, using two buffers (channels) per node.
-    let src_node_ptr = src_node as fn(&[Input], &mut [Buffer]);
+    let src_node_ptr = src_node as fn(&[Input<128>], &mut [Buffer<128>]);
     let src_a = g.add_node(NodeData::new2(BoxedNode::new(src_node_ptr)));
     let src_b = g.add_node(NodeData::new2(BoxedNode::new(src_node_ptr)));
     let src_c = g.add_node(NodeData::new2(BoxedNode::new(src_node_ptr)));
@@ -81,10 +81,10 @@ fn test_sum2() {
     p.process(&mut g, sum_ab_c);
 
     // sum_a_b should be 0.2.
-    let expected = vec![Buffer::from([0.2; Buffer::LEN]); 2];
+    let expected = vec![Buffer::from([0.2; 128]); 2];
     assert_eq!(&g[sum_a_b].buffers[..], &expected[..]);
     // sum_ab_c should be 0.3.
-    let expected = vec![Buffer::from([0.3; Buffer::LEN]); 2];
+    let expected = vec![Buffer::from([0.3; 128]); 2];
     assert_eq!(&g[sum_ab_c].buffers[..], &expected[..]);
 }
 
@@ -92,12 +92,12 @@ fn test_sum2() {
 fn test_sum_unboxed() {
     // Prove to ourselves we also support unboxed node types with a custom node type.
     enum TestNode {
-        SourceFnPtr(fn(&[Input], &mut [Buffer])),
+        SourceFnPtr(fn(&[Input<128>], &mut [Buffer<128>])),
         Sum(node::Sum),
     }
 
-    impl Node for TestNode {
-        fn process(&mut self, inputs: &[Input], output: &mut [Buffer]) {
+    impl Node<128> for TestNode {
+        fn process(&mut self, inputs: &[Input<128>], output: &mut [Buffer<128>]) {
             match *self {
                 TestNode::SourceFnPtr(ref mut f) => (*f)(inputs, output),
                 TestNode::Sum(ref mut sum) => sum.process(inputs, output),
@@ -106,8 +106,8 @@ fn test_sum_unboxed() {
     }
 
     // The type of graph to use for this test.
-    type Graph = petgraph::Graph<NodeData<TestNode>, (), petgraph::Directed, u32>;
-    type Processor = dasp_graph::Processor<Graph>;
+    type Graph = petgraph::Graph<NodeData<TestNode, 128>, (), petgraph::Directed, u32>;
+    type Processor = dasp_graph::Processor<Graph, 128>;
 
     // Create a graph and a processor.
     let mut g = Graph::new();
@@ -127,6 +127,6 @@ fn test_sum_unboxed() {
     p.process(&mut g, sum);
 
     // Check that `sum` actually contains the sum.
-    let expected = Buffer::from([0.2; Buffer::LEN]);
+    let expected = Buffer::from([0.2; 128]);
     assert_eq!(&g[sum].buffers[..], &[expected][..]);
 }