diff --git a/librapid/include/librapid/array/arrayContainer.hpp b/librapid/include/librapid/array/arrayContainer.hpp
index 9112da2c..a2831e10 100644
--- a/librapid/include/librapid/array/arrayContainer.hpp
+++ b/librapid/include/librapid/array/arrayContainer.hpp
@@ -71,12 +71,11 @@ namespace librapid {
 		template<typename T>
 		struct IsArrayContainer : std::false_type {};
 
-		template<size_t dims, typename StorageScalar>
-		struct IsArrayContainer<array::ArrayContainer<Shape<dims>, StorageScalar>>
-				: std::true_type {};
+		template<typename StorageScalar>
+		struct IsArrayContainer<array::ArrayContainer<Shape, StorageScalar>> : std::true_type {};
 
-		LIBRAPID_DEFINE_AS_TYPE(size_t dims COMMA typename StorageScalar,
-								array::ArrayContainer<Shape<dims> COMMA StorageScalar>);
+		LIBRAPID_DEFINE_AS_TYPE(typename StorageScalar,
+								array::ArrayContainer<Shape COMMA StorageScalar>);
 
 		LIBRAPID_DEFINE_AS_TYPE(typename StorageScalar,
 								array::ArrayContainer<MatrixShape COMMA StorageScalar>);
@@ -88,7 +87,7 @@ namespace librapid {
 		public:
 			using StorageType = StorageType_;
 			using ShapeType	  = ShapeType_;
-			using StrideType  = Stride<32>;
+			using StrideType  = Stride;
 			using SizeType	  = typename ShapeType::SizeType;
 			using Scalar	  = typename StorageType::Scalar;
 			using Packet	  = typename typetraits::TypeInfo<Scalar>::Packet;
@@ -582,11 +581,11 @@ namespace librapid {
 				auto subSize		= res.shape().size();
 				int64_t storageSize = sizeof(typename StorageType_::Scalar);
 				cl_buffer_region region {index * subSize * storageSize, subSize * storageSize};
-				res.m_storage.set(
+				res.m_storage =
 				  StorageType_(m_storage.data().createSubBuffer(
 								 StorageType_::bufferFlags, CL_BUFFER_CREATE_TYPE_REGION, &region),
 							   subSize,
-							   false));
+							   false);
 				return res;
 #else
 				LIBRAPID_ERROR("OpenCL support not enabled");
@@ -597,7 +596,7 @@ namespace librapid {
 				res.m_shape	  = m_shape.subshape(1, ndim());
 				auto subSize  = res.shape().size();
 				Scalar *begin = m_storage.begin().get() + index * subSize;
-				res.m_storage.set(StorageType_(begin, subSize, false));
+				res.m_storage = StorageType_(begin, subSize, false);
 				return res;
 #else
 				LIBRAPID_ERROR("CUDA support not enabled");
@@ -610,7 +609,7 @@ namespace librapid {
 				auto subSize  = res.shape().size();
 				Scalar *begin = m_storage.begin() + index * subSize;
 				Scalar *end	  = begin + subSize;
-				res.m_storage.set(StorageType_(begin, end, false));
+				res.m_storage = StorageType_(begin, end, false);
 				return res;
 			}
 		}
@@ -845,7 +844,7 @@ namespace librapid {
 		template<typename T, typename Char, typename Ctx>
 		LIBRAPID_ALWAYS_INLINE void ArrayContainer<ShapeType_, StorageType_>::str(
 		  const fmt::formatter<T, Char> &format, char bracket, char separator, Ctx &ctx) const {
-			GeneralArrayView(*this).str(format, bracket, separator, ctx);
+			createGeneralArrayView(*this).str(format, bracket, separator, ctx);
 		}
 	} // namespace array
 
diff --git a/librapid/include/librapid/array/arrayTypeDef.hpp b/librapid/include/librapid/array/arrayTypeDef.hpp
index cf3d5a1a..ef830d39 100644
--- a/librapid/include/librapid/array/arrayTypeDef.hpp
+++ b/librapid/include/librapid/array/arrayTypeDef.hpp
@@ -28,9 +28,10 @@ namespace librapid {
 	/// `backend::CPU`, `backend::CUDA` or any Storage interface
 	/// \tparam Scalar The scalar type of the array.
 	/// \tparam StorageType The storage type of the array.
-	template<typename Scalar, typename StorageType = backend::CPU>
+	template<typename Scalar, typename StorageType = backend::CPU, typename ShapeType = Shape,
+			 typename std::enable_if_t<typetraits::IsSizeType<ShapeType>::value, int> = 0>
 	using Array =
-	  array::ArrayContainer<Shape<LIBRAPID_MAX_ARRAY_DIMS>,
+	  array::ArrayContainer<Shape,
 							typename detail::TypeDefStorageEvaluator<Scalar, StorageType>::Type>;
 
 	/// A definition for fixed-size array objects.
@@ -38,15 +39,14 @@ namespace librapid {
 	/// \tparam Dimensions The dimensions of the array.
 	/// \see Array
 	template<typename Scalar, size_t... Dimensions>
-	using ArrayF =
-	  array::ArrayContainer<Shape<LIBRAPID_MAX_ARRAY_DIMS>, FixedStorage<Scalar, Dimensions...>>;
+	using ArrayF = array::ArrayContainer<Shape, FixedStorage<Scalar, Dimensions...>>;
 
 	/// A reference type for Array objects. Use this to accept Array objects as parameters since
 	/// the compiler cannot determine the templates tingle for the Array typedef. For more
 	/// granularity, you can also accept a raw ArrayContainer object. \tparam StorageType The
 	/// storage type of the array. \see Array \see ArrayF \see Function \see FunctionRef
 	template<typename StorageType>
-	using ArrayRef = array::ArrayContainer<Shape<LIBRAPID_MAX_ARRAY_DIMS>, StorageType>;
+	using ArrayRef = array::ArrayContainer<Shape, StorageType>;
 
 	template<typename Scalar, typename Backend = backend::CPU>
 	using Matrix =
diff --git a/librapid/include/librapid/array/generalArrayView.hpp b/librapid/include/librapid/array/generalArrayView.hpp
index 4af8570d..59180173 100644
--- a/librapid/include/librapid/array/generalArrayView.hpp
+++ b/librapid/include/librapid/array/generalArrayView.hpp
@@ -14,27 +14,33 @@ namespace librapid {
 		LIBRAPID_DEFINE_AS_TYPE(typename T, array::GeneralArrayView<T>);
 	} // namespace typetraits
 
+	template<typename T>
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto createGeneralArrayView(T &&array) {
+		return array::GeneralArrayView<T>(std::forward<T>(array));
+	}
+
 	namespace array {
 		template<typename ArrayViewType>
 		class GeneralArrayView {
 		public:
-			// using ArrayType		 = T;
 			using BaseType		 = typename std::decay_t<ArrayViewType>;
 			using Scalar		 = typename typetraits::TypeInfo<BaseType>::Scalar;
 			using Reference		 = BaseType &;
 			using ConstReference = const BaseType &;
 			using Backend		 = typename typetraits::TypeInfo<BaseType>::Backend;
-			using ArrayType		 = Array<Scalar, Backend>;
-			using StrideType	 = typename ArrayType::StrideType;
-			using ShapeType		 = typename ArrayType::ShapeType;
-			using Iterator		 = detail::ArrayIterator<GeneralArrayView>;
+			using StrideType	 = typename BaseType::StrideType;
+			using ShapeType		 = typename BaseType::ShapeType;
+			using StorageType	 = typename BaseType::StorageType;
+			// using ArrayType		 = Array<Scalar, Backend>;
+			using ArrayType = array::ArrayContainer<ShapeType, StorageType>;
+			using Iterator	= detail::ArrayIterator<GeneralArrayView>;
 
 			/// Default constructor should never be used
 			GeneralArrayView() = delete;
 
 			/// Copy an ArrayView object
 			/// \param array The array to copy
-			LIBRAPID_ALWAYS_INLINE GeneralArrayView(ArrayViewType &array);
+			// LIBRAPID_ALWAYS_INLINE GeneralArrayView(ArrayViewType &array);
 
 			/// Copy an ArrayView object (not const)
 			/// \param array The array to copy
@@ -57,7 +63,7 @@ namespace librapid {
 			/// Assigns a temporary ArrayView to this ArrayView.
 			/// \param other The ArrayView to move.
 			/// \return A reference to this ArrayView.
-			// ArrayView &operator=(ArrayView &&other) noexcept = default;
+			GeneralArrayView &operator=(GeneralArrayView &&other) noexcept = default;
 
 			/// Assign a scalar value to this ArrayView. This function should only be used to
 			/// assign to a zero-dimensional "scalar" ArrayView, and will throw an error if used
@@ -140,17 +146,17 @@ namespace librapid {
 					 Ctx &ctx) const;
 
 		private:
-			ArrayViewType &m_ref;
+			ArrayViewType m_ref;
 			ShapeType m_shape;
 			StrideType m_stride;
 			int64_t m_offset = 0;
 		};
 
-		template<typename ArrayViewType>
-		LIBRAPID_ALWAYS_INLINE
-		GeneralArrayView<ArrayViewType>::GeneralArrayView(ArrayViewType &array) :
-				m_ref(array),
-				m_shape(array.shape()), m_stride(array.shape()) {}
+		// template<typename ArrayViewType>
+		// LIBRAPID_ALWAYS_INLINE
+		// GeneralArrayView<ArrayViewType>::GeneralArrayView(ArrayViewType &array) :
+		// 		m_ref(array),
+		// 		m_shape(array.shape()), m_stride(array.shape()) {}
 
 		template<typename ArrayViewType>
 		LIBRAPID_ALWAYS_INLINE
@@ -202,7 +208,7 @@ namespace librapid {
 			  "Index {} out of bounds in ArrayContainer::operator[] with leading dimension={}",
 			  index,
 			  m_shape[0]);
-			GeneralArrayView<T> view(m_ref);
+			GeneralArrayView view(createGeneralArrayView(m_ref));
 			const auto stride = Stride(m_shape);
 			view.setShape(m_shape.subshape(1, ndim()));
 			if (ndim() == 1)
@@ -221,7 +227,7 @@ namespace librapid {
 			  "Index {} out of bounds in ArrayContainer::operator[] with leading dimension={}",
 			  index,
 			  m_shape[0]);
-			GeneralArrayView<T> view(m_ref);
+			GeneralArrayView view(createGeneralArrayView(m_ref));
 			const auto stride = Stride(m_shape);
 			view.setShape(m_shape.subshape(1, ndim()));
 			if (ndim() == 1)
diff --git a/librapid/include/librapid/array/linalg/transpose.hpp b/librapid/include/librapid/array/linalg/transpose.hpp
index d5e698f9..26748561 100644
--- a/librapid/include/librapid/array/linalg/transpose.hpp
+++ b/librapid/include/librapid/array/linalg/transpose.hpp
@@ -634,9 +634,11 @@ namespace librapid {
 		}
 	}; // namespace array
 
-	template<typename T, typename ShapeType = Shape<size_t, 32>,
-			 typename std::enable_if_t<
-			   typetraits::TypeInfo<T>::type == detail::LibRapidType::ArrayContainer, int> = 0>
+	template<typename T, typename ShapeType = MatrixShape,
+			 typename std::enable_if_t<typetraits::TypeInfo<T>::type ==
+										   detail::LibRapidType::ArrayContainer &&
+										 typetraits::IsSizeType<ShapeType>::value,
+									   int> = 0>
 	auto transpose(T &&array, const ShapeType &axes = ShapeType()) {
 		// If axes is empty, transpose the array in reverse order
 		ShapeType newAxes = axes;
@@ -648,9 +650,11 @@ namespace librapid {
 		return array::Transpose(array, newAxes);
 	}
 
-	template<typename T, typename ShapeType = Shape<size_t, 32>,
-			 typename std::enable_if_t<
-			   typetraits::TypeInfo<T>::type != detail::LibRapidType::ArrayContainer, int> = 0>
+	template<typename T, typename ShapeType = MatrixShape,
+			 typename std::enable_if_t<typetraits::TypeInfo<T>::type !=
+										   detail::LibRapidType::ArrayContainer &&
+										 typetraits::IsSizeType<ShapeType>::value,
+									   int> = 0>
 	auto transpose(const T &function, const ShapeType &axes = ShapeType()) {
 		// If axes is empty, transpose the array in reverse order
 		auto array		  = function.eval();
diff --git a/librapid/include/librapid/array/pseudoConstructors.hpp b/librapid/include/librapid/array/pseudoConstructors.hpp
index 91c6427c..ae06ba12 100644
--- a/librapid/include/librapid/array/pseudoConstructors.hpp
+++ b/librapid/include/librapid/array/pseudoConstructors.hpp
@@ -51,9 +51,9 @@ namespace librapid {
 	/// \tparam N Maximum number of dimensions of the Shape
 	/// \param shape Shape of the Array
 	/// \return Array filled with zeros
-	template<typename Scalar = double, typename Backend = backend::CPU,
-			 size_t N = LIBRAPID_MAX_ARRAY_DIMS>
-	Array<Scalar, Backend> zeros(const Shape<N> &shape) {
+	template<typename Scalar = double, typename Backend = backend::CPU, typename ShapeType = Shape,
+			 typename std::enable_if_t<typetraits::IsSizeType<ShapeType>::value, int> = 0>
+	Array<Scalar, Backend> zeros(const ShapeType &shape) {
 		return Array<Scalar, Backend>(shape, Scalar(0));
 	}
 
@@ -79,9 +79,9 @@ namespace librapid {
 	/// \tparam N Maximum number of dimensions of the Shape
 	/// \param shape Shape of the Array
 	/// \return Array filled with ones
-	template<typename Scalar = double, typename Backend = backend::CPU,
-			 size_t N = LIBRAPID_MAX_ARRAY_DIMS>
-	Array<Scalar, Backend> ones(const Shape<N> &shape) {
+	template<typename Scalar = double, typename Backend = backend::CPU, typename ShapeType = Shape,
+			 typename std::enable_if_t<typetraits::IsSizeType<ShapeType>::value, int> = 0>
+	Array<Scalar, Backend> ones(const ShapeType &shape) {
 		return Array<Scalar, Backend>(shape, Scalar(1));
 	}
 
@@ -109,11 +109,11 @@ namespace librapid {
 	/// \tparam N Maximum number of dimensions of the Shape
 	/// \param shape Shape of the Array
 	/// \return Array filled with numbers from 0 to N-1
-	template<typename Scalar = int64_t, typename Backend = backend::CPU,
-			 size_t N = LIBRAPID_MAX_ARRAY_DIMS>
-	Array<Scalar, Backend> ordered(const Shape<N> &shape) {
+	template<typename Scalar = int64_t, typename Backend = backend::CPU, typename ShapeType = Shape,
+			 typename std::enable_if_t<typetraits::IsSizeType<ShapeType>::value, int> = 0>
+	Array<Scalar, Backend> ordered(const ShapeType &shape) {
 		Array<Scalar, Backend> result(shape);
-		for (size_t i = 0; i < shape.size(); i++) { result.storage()[i] = Scalar(i); }
+		for (size_t i = 0; i < result.size(); i++) { result.storage()[i] = Scalar(i); }
 		return result;
 	}
 
diff --git a/librapid/include/librapid/array/shape.hpp b/librapid/include/librapid/array/shape.hpp
index b3b92673..1bc28e56 100644
--- a/librapid/include/librapid/array/shape.hpp
+++ b/librapid/include/librapid/array/shape.hpp
@@ -8,15 +8,14 @@
 
 namespace librapid {
 	namespace typetraits {
-		LIBRAPID_DEFINE_AS_TYPE(size_t N, Shape<N>);
+		LIBRAPID_DEFINE_AS_TYPE_NO_TEMPLATE(Shape);
 		LIBRAPID_DEFINE_AS_TYPE_NO_TEMPLATE(MatrixShape);
 	} // namespace typetraits
 
-	template<size_t N = LIBRAPID_MAX_ARRAY_DIMS>
 	class Shape {
 	public:
 		using SizeType						  = uint32_t;
-		static constexpr size_t MaxDimensions = N;
+		static constexpr size_t MaxDimensions = LIBRAPID_MAX_ARRAY_DIMS;
 
 		/// Default constructor
 		LIBRAPID_ALWAYS_INLINE Shape() = default;
@@ -49,20 +48,13 @@ namespace librapid {
 		/// \param other Temporary Shape object to copy
 		LIBRAPID_ALWAYS_INLINE Shape(Shape &&other) noexcept = default;
 
-		/// Create a Shape object from one with a different type and number of dimensions.
-		/// \tparam V Scalar type of the values
-		/// \tparam Dim	Number of dimensions
-		/// \param other Shape object to copy
-		template<size_t Dim>
-		LIBRAPID_ALWAYS_INLINE Shape(const Shape<Dim> &other);
-
 		/// Create a Shape object from one with a different type and number of dimensions, moving it
 		/// instead of copying it.
 		/// \tparam V Scalar type of the values
 		/// \tparam Dim Number of dimensions
 		/// \param other Temporary Shape object to move
 		template<size_t Dim>
-		LIBRAPID_ALWAYS_INLINE Shape(Shape<Dim> &&other) noexcept;
+		LIBRAPID_ALWAYS_INLINE Shape(Shape &&other) noexcept;
 
 		/// Assign a Shape object to this object
 		/// \tparam V Scalar type of the Shape
@@ -143,7 +135,7 @@ namespace librapid {
 
 	protected:
 		int m_dims;
-		std::array<SizeType, N> m_data;
+		std::array<SizeType, MaxDimensions> m_data;
 	};
 
 	class MatrixShape {
@@ -178,9 +170,11 @@ namespace librapid {
 		LIBRAPID_ALWAYS_INLINE MatrixShape &operator=(MatrixShape &&other) noexcept = default;
 
 		static LIBRAPID_ALWAYS_INLINE auto zeros() -> MatrixShape;
-
 		static LIBRAPID_ALWAYS_INLINE auto ones() -> MatrixShape;
 
+		static LIBRAPID_ALWAYS_INLINE auto zeros(size_t) -> MatrixShape;
+		static LIBRAPID_ALWAYS_INLINE auto ones(size_t) -> MatrixShape;
+
 		template<typename Index>
 		LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator[](Index index) const
 		  -> const SizeType &;
@@ -193,7 +187,7 @@ namespace librapid {
 		LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE constexpr auto ndim() const -> int;
 
 		LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto subshape(size_t start, size_t end) const
-		  -> Shape<LIBRAPID_MAX_ARRAY_DIMS>;
+		  -> Shape;
 
 		LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto size() const -> size_t;
 
@@ -207,101 +201,56 @@ namespace librapid {
 
 	namespace detail {
 		template<typename T, size_t... Dims>
-		Shape<LIBRAPID_MAX_ARRAY_DIMS> shapeFromFixedStorage(const FixedStorage<T, Dims...> &) {
-			return Shape<LIBRAPID_MAX_ARRAY_DIMS>({Dims...});
+		Shape shapeFromFixedStorage(const FixedStorage<T, Dims...> &) {
+			return Shape({Dims...});
 		}
 	} // namespace detail
 
-	template<size_t N>
 	template<typename Scalar, size_t... Dimensions>
-	LIBRAPID_ALWAYS_INLINE Shape<N>::Shape(const FixedStorage<Scalar, Dimensions...> &) :
+	LIBRAPID_ALWAYS_INLINE Shape::Shape(const FixedStorage<Scalar, Dimensions...> &) :
 			m_data({Dimensions...}) {}
 
-	template<size_t N>
 	template<typename V>
-	LIBRAPID_ALWAYS_INLINE Shape<N>::Shape(const std::initializer_list<V> &vals) :
+	LIBRAPID_ALWAYS_INLINE Shape::Shape(const std::initializer_list<V> &vals) :
 			m_dims(vals.size()) {
-		LIBRAPID_ASSERT(vals.size() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						vals.size());
 		for (size_t i = 0; i < vals.size(); ++i) { m_data[i] = *(vals.begin() + i); }
 	}
 
-	template<size_t N>
 	template<typename V>
-	LIBRAPID_ALWAYS_INLINE Shape<N>::Shape(const std::vector<V> &vals) : m_dims(vals.size()) {
-		LIBRAPID_ASSERT(vals.size() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						vals.size());
+	LIBRAPID_ALWAYS_INLINE Shape::Shape(const std::vector<V> &vals) : m_dims(vals.size()) {
 		for (size_t i = 0; i < vals.size(); ++i) { m_data[i] = vals[i]; }
 	}
 
-	template<size_t N>
-	template<size_t Dim>
-	LIBRAPID_ALWAYS_INLINE Shape<N>::Shape(const Shape<Dim> &other) : m_dims(other.ndim()) {
-		LIBRAPID_ASSERT(other.ndim() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						other.ndim());
-		for (size_t i = 0; i < m_dims; ++i) { m_data[i] = other[i]; }
-	}
-
-	template<size_t N>
-	template<size_t Dim>
-	LIBRAPID_ALWAYS_INLINE Shape<N>::Shape(Shape<Dim> &&other) noexcept : m_dims(other.ndim()) {
-		LIBRAPID_ASSERT(other.ndim() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						other.ndim());
-		for (size_t i = 0; i < m_dims; ++i) { m_data[i] = other[i]; }
-	}
-
-	template<size_t N>
 	template<typename V>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator=(const std::initializer_list<V> &vals)
-	  -> Shape & {
-		LIBRAPID_ASSERT(vals.size() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						vals.size());
+	LIBRAPID_ALWAYS_INLINE auto Shape::operator=(const std::initializer_list<V> &vals) -> Shape & {
 		m_dims = vals.size();
 		for (int64_t i = 0; i < vals.size(); ++i) { m_data[i] = *(vals.begin() + i); }
 		return *this;
 	}
 
-	template<size_t N>
 	template<typename V>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator=(const std::vector<V> &vals) -> Shape & {
-		LIBRAPID_ASSERT(vals.size() <= N,
-						"Shape object is limited to {} dimensions. Cannot initialize with {}",
-						N,
-						vals.size());
+	LIBRAPID_ALWAYS_INLINE auto Shape::operator=(const std::vector<V> &vals) -> Shape & {
 		m_dims = vals.size();
 		for (int64_t i = 0; i < vals.size(); ++i) { m_data[i] = vals[i]; }
 		return *this;
 	}
 
-	template<size_t N>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::zeros(size_t dims) -> Shape {
+	LIBRAPID_ALWAYS_INLINE auto Shape::zeros(size_t dims) -> Shape {
 		Shape res;
 		res.m_dims = dims;
 		for (size_t i = 0; i < dims; ++i) res.m_data[i] = 0;
 		return res;
 	}
 
-	template<size_t N>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::ones(size_t dims) -> Shape {
+	LIBRAPID_ALWAYS_INLINE auto Shape::ones(size_t dims) -> Shape {
 		Shape res;
 		res.m_dims = dims;
 		for (size_t i = 0; i < dims; ++i) res.m_data[i] = 1;
 		return res;
 	}
 
-	template<size_t N>
 	template<typename Index>
-	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator[](Index index) const
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape::operator[](Index index) const
 	  -> const SizeType & {
 		static_assert(std::is_integral_v<Index>, "Index must be an integral type");
 		LIBRAPID_ASSERT(index < m_dims, "Index out of bounds");
@@ -309,17 +258,15 @@ namespace librapid {
 		return m_data[index];
 	}
 
-	template<size_t N>
 	template<typename Index>
-	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator[](Index index) -> SizeType & {
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape::operator[](Index index) -> SizeType & {
 		static_assert(std::is_integral_v<Index>, "Index must be an integral type");
 		LIBRAPID_ASSERT(index < m_dims, "Index out of bounds");
 		LIBRAPID_ASSERT(index >= 0, "Index out of bounds");
 		return m_data[index];
 	}
 
-	template<size_t N>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator==(const Shape &other) const -> bool {
+	LIBRAPID_ALWAYS_INLINE auto Shape::operator==(const Shape &other) const -> bool {
 		if (m_dims != other.m_dims) return false;
 		for (size_t i = 0; i < m_dims; ++i) {
 			if (m_data[i] != other.m_data[i]) return false;
@@ -327,18 +274,13 @@ namespace librapid {
 		return true;
 	}
 
-	template<size_t N>
-	LIBRAPID_ALWAYS_INLINE auto Shape<N>::operator!=(const Shape &other) const -> bool {
+	LIBRAPID_ALWAYS_INLINE auto Shape::operator!=(const Shape &other) const -> bool {
 		return !(*this == other);
 	}
 
-	template<size_t N>
-	LIBRAPID_NODISCARD auto Shape<N>::ndim() const -> int {
-		return m_dims;
-	}
+	LIBRAPID_NODISCARD auto Shape::ndim() const -> int { return m_dims; }
 
-	template<size_t N>
-	LIBRAPID_NODISCARD auto Shape<N>::subshape(size_t start, size_t end) const -> Shape {
+	LIBRAPID_NODISCARD auto Shape::subshape(size_t start, size_t end) const -> Shape {
 		LIBRAPID_ASSERT(start <= end, "Start index must be less than end index");
 		LIBRAPID_ASSERT(end <= m_dims,
 						"End index must be less than or equal to the number of dimensions");
@@ -350,17 +292,14 @@ namespace librapid {
 		return res;
 	}
 
-	template<size_t N>
-	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape<N>::size() const -> size_t {
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto Shape::size() const -> size_t {
 		size_t res = 1;
 		for (size_t i = 0; i < m_dims; ++i) res *= m_data[i];
 		return res;
 	}
 
-	template<size_t N>
 	template<typename T_, typename Char, typename Ctx>
-	LIBRAPID_ALWAYS_INLINE void Shape<N>::str(const fmt::formatter<T_, Char> &format,
-											  Ctx &ctx) const {
+	LIBRAPID_ALWAYS_INLINE void Shape::str(const fmt::formatter<T_, Char> &format, Ctx &ctx) const {
 		fmt::format_to(ctx.out(), "Shape(");
 		for (size_t i = 0; i < m_dims; ++i) {
 			format.format(m_data[i], ctx);
@@ -406,9 +345,16 @@ namespace librapid {
 	}
 
 	LIBRAPID_ALWAYS_INLINE auto MatrixShape::zeros() -> MatrixShape { return MatrixShape({0, 0}); }
-
 	LIBRAPID_ALWAYS_INLINE auto MatrixShape::ones() -> MatrixShape { return MatrixShape({1, 1}); }
 
+	LIBRAPID_ALWAYS_INLINE auto MatrixShape::zeros(size_t) -> MatrixShape {
+		return MatrixShape({0, 0});
+	}
+
+	LIBRAPID_ALWAYS_INLINE auto MatrixShape::ones(size_t) -> MatrixShape {
+		return MatrixShape({1, 1});
+	}
+
 	template<typename Index>
 	LIBRAPID_ALWAYS_INLINE auto MatrixShape::operator[](Index index) const -> const SizeType & {
 		static_assert(std::is_integral_v<Index>, "Index must be an integral type");
@@ -429,14 +375,13 @@ namespace librapid {
 
 	LIBRAPID_ALWAYS_INLINE constexpr auto MatrixShape::ndim() const -> int { return 2; }
 
-	LIBRAPID_ALWAYS_INLINE auto MatrixShape::subshape(size_t start, size_t end) const
-	  -> Shape<LIBRAPID_MAX_ARRAY_DIMS> {
+	LIBRAPID_ALWAYS_INLINE auto MatrixShape::subshape(size_t start, size_t end) const -> Shape {
 		LIBRAPID_ASSERT(start <= end, "Start index must be less than end index");
 		LIBRAPID_ASSERT(end <= 2,
 						"End index must be less than or equal to the number of dimensions");
 		LIBRAPID_ASSERT(start >= 0, "Start index must be greater than or equal to 0");
 
-		Shape<LIBRAPID_MAX_ARRAY_DIMS> res;
+		Shape res;
 		res[0] = m_rows;
 		res[1] = m_cols;
 		return res.subshape(start, end);
@@ -454,27 +399,23 @@ namespace librapid {
 		fmt::format_to(ctx.out(), ")");
 	}
 
-	template<size_t N>
-	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator==(const Shape<N> &lhs,
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator==(const Shape &lhs,
 															  const MatrixShape &rhs) -> bool {
 		return lhs.ndim() == 2 && lhs[0] == rhs[0] && lhs[1] == rhs[1];
 	}
 
-	template<size_t N>
 	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator==(const MatrixShape &lhs,
-															  const Shape<N> &rhs) -> bool {
+															  const Shape &rhs) -> bool {
 		return rhs == lhs;
 	}
 
-	template<size_t N>
-	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator!=(const Shape<N> &lhs,
+	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator!=(const Shape &lhs,
 															  const MatrixShape &rhs) -> bool {
 		return !(lhs == rhs);
 	}
 
-	template<size_t N>
 	LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto operator!=(const MatrixShape &lhs,
-															  const Shape<N> &rhs) -> bool {
+															  const Shape &rhs) -> bool {
 		return !(lhs == rhs);
 	}
 
@@ -482,8 +423,8 @@ namespace librapid {
 		template<typename T>
 		struct IsSizeType : std::false_type {};
 
-		template<size_t N>
-		struct IsSizeType<Shape<N>> : std::true_type {};
+		template<>
+		struct IsSizeType<Shape> : std::true_type {};
 
 		template<>
 		struct IsSizeType<MatrixShape> : std::true_type {};
@@ -537,19 +478,19 @@ namespace librapid {
 			using Type = std::false_type;
 		};
 
-		template<size_t N, size_t M>
-		struct ShapeTypeHelperImpl<Shape<N>, Shape<M>> {
-			using Type = Shape<(N > M ? N : M)>;
+		template<>
+		struct ShapeTypeHelperImpl<Shape, Shape> {
+			using Type = Shape;
 		};
 
-		template<size_t N>
-		struct ShapeTypeHelperImpl<Shape<N>, MatrixShape> {
-			using Type = Shape<N>;
+		template<>
+		struct ShapeTypeHelperImpl<Shape, MatrixShape> {
+			using Type = Shape;
 		};
 
-		template<size_t N>
-		struct ShapeTypeHelperImpl<MatrixShape, Shape<N>> {
-			using Type = Shape<N>;
+		template<>
+		struct ShapeTypeHelperImpl<MatrixShape, Shape> {
+			using Type = Shape;
 		};
 
 		template<>
@@ -572,11 +513,12 @@ namespace librapid {
 
 // Support FMT printing
 #ifdef FMT_API
-template<size_t N>
-struct fmt::formatter<librapid::Shape<N>> {
+
+template<>
+struct fmt::formatter<librapid::Shape> {
 private:
-	using Type	   = librapid::Shape<N>;
-	using SizeType = librapid::Shape<N>::SizeType;
+	using Type	   = librapid::Shape;
+	using SizeType = librapid::Shape::SizeType;
 	using Base	   = fmt::formatter<SizeType, char>;
 	Base m_base;
 
diff --git a/librapid/include/librapid/array/strideTools.hpp b/librapid/include/librapid/array/strideTools.hpp
index 6d4af178..97684dae 100644
--- a/librapid/include/librapid/array/strideTools.hpp
+++ b/librapid/include/librapid/array/strideTools.hpp
@@ -3,7 +3,7 @@
 
 namespace librapid {
 	namespace typetraits {
-		LIBRAPID_DEFINE_AS_TYPE(size_t N, Stride<N>);
+		LIBRAPID_DEFINE_AS_TYPE_NO_TEMPLATE(Stride);
 	}
 
 	/// A Stride is a vector of integers that describes the distance between elements in each
@@ -13,44 +13,42 @@ namespace librapid {
 	/// \tparam T The type of the Stride. Must be an integer type.
 	/// \tparam N The number of dimensions in the Stride.
 	/// \see Shape
-	template<size_t N = LIBRAPID_MAX_ARRAY_DIMS>
-	class Stride : public Shape<N> {
+	class Stride : public Shape {
 	public:
 		/// Default Constructor
-		Stride() = default;
+		LIBRAPID_ALWAYS_INLINE Stride() = default;
 
 		/// Construct a Stride from a Shape object. This will assume that the data represented by
 		/// the Shape object is a contiguous block of memory, and will calculate the corresponding
 		/// strides based on this.
 		/// \param shape
-		Stride(const Shape<N> &shape);
+		LIBRAPID_ALWAYS_INLINE Stride(const Shape &shape);
 
 		/// Copy a Stride object
 		/// \param other The Stride object to copy.
-		Stride(const Stride &other) = default;
+		LIBRAPID_ALWAYS_INLINE Stride(const Stride &other) = default;
 
 		/// Move a Stride object
 		/// \param other The Stride object to move.
-		Stride(Stride &&other) noexcept = default;
+		LIBRAPID_ALWAYS_INLINE Stride(Stride &&other) noexcept = default;
 
 		/// Assign a Stride object to this Stride object.
 		/// \param other The Stride object to assign.
-		Stride &operator=(const Stride &other) = default;
+		LIBRAPID_ALWAYS_INLINE Stride &operator=(const Stride &other) = default;
 
 		/// Move a Stride object to this Stride object.
 		/// \param other The Stride object to move.
-		Stride &operator=(Stride &&other) noexcept = default;
+		LIBRAPID_ALWAYS_INLINE Stride &operator=(Stride &&other) noexcept = default;
 	};
 
-	template<size_t N>
-	Stride<N>::Stride(const Shape<N> &shape) : Shape<N>(shape) {
+	LIBRAPID_ALWAYS_INLINE Stride::Stride(const Shape &shape) : Shape(shape) {
 		if (this->m_dims == 0) {
 			// Edge case for a zero-dimensional array
 			this->m_data[0] = 1;
 			return;
 		}
 
-		typename Shape<N>::SizeType tmp[N] {0};
+		typename Shape::SizeType tmp[MaxDimensions] {0};
 		tmp[this->m_dims - 1] = 1;
 		for (size_t i = this->m_dims - 1; i > 0; --i) tmp[i - 1] = tmp[i] * this->m_data[i];
 		for (size_t i = 0; i < this->m_dims; ++i) this->m_data[i] = tmp[i];
@@ -58,8 +56,12 @@ namespace librapid {
 } // namespace librapid
 
 // Support FMT printing
-#ifdef FMT_API
-LIBRAPID_SIMPLE_IO_IMPL(size_t N, librapid::Stride<N>)
-#endif // FMT_API
+template<>
+struct fmt::formatter<librapid::Stride> : fmt::formatter<librapid::Shape> {
+	template<typename FormatContext>
+	auto format(const librapid::Stride &stride, FormatContext &ctx) {
+		return fmt::formatter<librapid::Shape>::format(stride, ctx);
+	}
+};
 
 #endif // LIBRAPID_ARRAY_STRIDE_TOOLS_HPP
\ No newline at end of file
diff --git a/librapid/include/librapid/core/forward.hpp b/librapid/include/librapid/core/forward.hpp
index 5790c769..9cdf0807 100644
--- a/librapid/include/librapid/core/forward.hpp
+++ b/librapid/include/librapid/core/forward.hpp
@@ -4,12 +4,8 @@
 #ifndef LIBRAPID_DOXYGEN
 
 namespace librapid {
-    template<size_t N>
     class Shape;
-
 	class MatrixShape;
-
-    template<size_t N>
     class Stride;
 
     template<typename Scalar_>