diff --git a/src/rb/macros.rs b/src/rb/macros.rs
index 7099b8a..26251d3 100644
--- a/src/rb/macros.rs
+++ b/src/rb/macros.rs
@@ -6,6 +6,13 @@ macro_rules! rb_impl_init {
             }
         }
 
+        impl<T, const N: usize> From<[T; N]> for $type<crate::storage::Array<T, N>> {
+            fn from(value: [T; N]) -> Self {
+                let (read, write) = (0, value.len());
+                unsafe { Self::from_raw_parts(crate::utils::array_to_uninit(value).into(), read, write) }
+            }
+        }
+
         #[cfg(feature = "alloc")]
         impl<T> $type<crate::storage::Heap<T>> {
             /// Creates a new instance of a ring buffer.
diff --git a/src/tests/init.rs b/src/tests/init.rs
index 0fcd511..89a1fdd 100644
--- a/src/tests/init.rs
+++ b/src/tests/init.rs
@@ -1,7 +1,26 @@
 use super::Rb;
-use crate::{storage::Heap, traits::*};
+#[cfg(feature = "alloc")]
+use crate::storage::Heap;
+use crate::traits::*;
+#[cfg(feature = "alloc")]
 use alloc::{boxed::Box, vec::Vec};
 
+#[test]
+fn from_array() {
+    let mut rb = Rb::from([123, 321]);
+    let (mut prod, mut cons) = rb.split_ref();
+
+    assert_eq!(prod.capacity().get(), 2);
+    assert_eq!(cons.occupied_len(), 2);
+
+    assert_eq!(prod.try_push(444), Err(444));
+
+    assert_eq!(cons.try_pop(), Some(123));
+    assert_eq!(cons.try_pop(), Some(321));
+    assert_eq!(cons.try_pop(), None);
+}
+
+#[cfg(feature = "alloc")]
 #[test]
 fn new() {
     const CAP: usize = 2;
@@ -19,11 +38,12 @@ fn new() {
     assert_eq!(cons.try_pop(), None);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn from_vec() {
-    let mut vec = Vec::with_capacity(2);
+    let mut vec = Vec::<i32>::with_capacity(2);
     vec.push(123);
-    let rb = Rb::<Heap<i32>>::from(vec);
+    let rb = Rb::from(vec);
     let (mut prod, mut cons) = rb.split();
 
     assert_eq!(prod.capacity().get(), 2);
@@ -37,10 +57,11 @@ fn from_vec() {
     assert_eq!(cons.try_pop(), None);
 }
 
+#[cfg(feature = "alloc")]
 #[test]
 fn from_boxed_slice() {
     let boxed_slice = Box::new([123, 321]) as Box<[i32]>;
-    let rb = Rb::<Heap<i32>>::from(boxed_slice);
+    let rb = Rb::from(boxed_slice);
     let (mut prod, mut cons) = rb.split();
 
     assert_eq!(prod.capacity().get(), 2);
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index e0f15fa..09fe142 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -10,7 +10,6 @@ mod drop;
 mod fmt_write;
 mod frozen;
 mod hold;
-#[cfg(feature = "alloc")]
 mod init;
 mod iter;
 mod overwrite;
diff --git a/src/utils.rs b/src/utils.rs
index f6fc935..68645fd 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -29,6 +29,12 @@ pub unsafe fn write_uninit_slice<'a, T: Copy>(dst: &'a mut [T], src: &[MaybeUnin
     dst
 }
 
+pub fn array_to_uninit<T, const N: usize>(value: [T; N]) -> [MaybeUninit<T>; N] {
+    let value = mem::ManuallyDrop::new(value);
+    let ptr = &value as *const _ as *const [MaybeUninit<T>; N];
+    unsafe { ptr.read() }
+}
+
 #[cfg(feature = "alloc")]
 pub fn vec_to_uninit<T>(value: Vec<T>) -> Vec<MaybeUninit<T>> {
     let value = mem::ManuallyDrop::new(value);