diff --git a/src/device_traits.rs b/src/device_traits.rs
index 4d5eaece..8f1599cf 100644
--- a/src/device_traits.rs
+++ b/src/device_traits.rs
@@ -83,6 +83,5 @@ pub trait Retriever<T>: Device {
         parents: impl Parents<NUM_PARENTS>,
     ) -> Buffer<T, Self, S>
     where
-        T: 'static,
         S: Shape;
 }
diff --git a/src/devices.rs b/src/devices.rs
index ce495ed3..c8dea160 100644
--- a/src/devices.rs
+++ b/src/devices.rs
@@ -30,7 +30,7 @@ pub use cdatatype::*;
 #[cfg(all(any(feature = "cpu", feature = "stack"), feature = "macro"))]
 mod cpu_stack_ops;
 
-use crate::{Alloc, Buffer, HasId, OnDropBuffer, PtrType, Shape};
+use crate::{Buffer, HasId, OnDropBuffer, PtrType, Shape};
 
 pub trait Device: OnDropBuffer + Sized {
     type Data<T, S: Shape>: HasId + PtrType;
@@ -89,8 +89,8 @@ macro_rules! impl_buffer_hook_traits {
 
 #[macro_export]
 macro_rules! impl_retriever {
-    ($device:ident) => {
-        impl<T: 'static, Mods: crate::Retrieve<Self, T>> crate::Retriever<T> for $device<Mods> {
+    ($device:ident, $($trait_bounds:tt)*) => {
+        impl<T: $( $trait_bounds )*, Mods: crate::Retrieve<Self, T>> crate::Retriever<T> for $device<Mods> {
             #[inline]
             fn retrieve<S: Shape, const NUM_PARENTS: usize>(
                 &self,
@@ -99,7 +99,7 @@ macro_rules! impl_retriever {
             ) -> Buffer<T, Self, S> {
                 let data = self
                     .modules
-                    .retrieve::<T, S, NUM_PARENTS>(self, len, parents);
+                    .retrieve::<S, NUM_PARENTS>(self, len, parents);
                 let buf = Buffer {
                     data,
                     device: Some(self),
@@ -109,4 +109,8 @@ macro_rules! impl_retriever {
             }
         }
     };
+
+    ($device:ident) => {
+        impl_retriever!($device, Sized);
+    }
 }
diff --git a/src/devices/cpu/cpu_device.rs b/src/devices/cpu/cpu_device.rs
index 1c6e5825..ea4e4a55 100644
--- a/src/devices/cpu/cpu_device.rs
+++ b/src/devices/cpu/cpu_device.rs
@@ -3,7 +3,7 @@ use core::convert::Infallible;
 use crate::{
     cpu::CPUPtr, flag::AllocFlag, impl_buffer_hook_traits, impl_retriever, Alloc, Base, Buffer,
     Cached, CachedModule, CloneBuf, Device, HasModules, LazySetup, MainMemory, Module,
-    OnDropBuffer, OnNewBuffer, Retrieve, Retriever, Setup, Shape, TapeActions,
+    OnDropBuffer, OnNewBuffer, Retrieve, Retriever, Setup, Shape, TapeActions, DevicelessAble,
 };
 
 pub trait IsCPU {}
@@ -49,6 +49,10 @@ impl<Mods: OnDropBuffer> Device for CPU<Mods> {
     }
 }
 
+impl<T, S: Shape> DevicelessAble<'_, T, S> for CPU<Base> {
+
+}
+
 impl<Mods: OnDropBuffer> MainMemory for CPU<Mods> {
     #[inline]
     fn as_ptr<T, S: Shape>(ptr: &Self::Data<T, S>) -> *const T {
diff --git a/src/devices/stack/mod.rs b/src/devices/stack/mod.rs
index 064532fc..8b6926d4 100644
--- a/src/devices/stack/mod.rs
+++ b/src/devices/stack/mod.rs
@@ -48,7 +48,7 @@ mod tests {
     impl<T, D> AddBuf<T, D> for CPU
     where
         D: MainMemory,
-        T: Add<Output = T> + Clone + 'static,
+        T: Add<Output = T> + Clone,
     {
         fn add(&self, lhs: &Buffer<T, D>, rhs: &Buffer<T, D>) -> Buffer<T, Self> {
             let len = core::cmp::min(lhs.len(), rhs.len());
@@ -65,7 +65,7 @@ mod tests {
     where
         Stack: Alloc<T>,
         D: MainMemory,
-        T: Add<Output = T> + Clone + 'static,
+        T: Add<Output = T> + Copy + Default,
     {
         fn add(&self, lhs: &Buffer<T, D, S>, rhs: &Buffer<T, D, S>) -> Buffer<T, Self, S> {
             let mut out = self.retrieve(S::LEN, (lhs, rhs));
diff --git a/src/devices/stack/stack_device.rs b/src/devices/stack/stack_device.rs
index dd32eac2..bfd92d34 100644
--- a/src/devices/stack/stack_device.rs
+++ b/src/devices/stack/stack_device.rs
@@ -1,8 +1,8 @@
-use core::{convert::Infallible, marker::PhantomData};
+use core::convert::Infallible;
 
 use crate::{
     flag::AllocFlag, shape::Shape, Alloc, Base, Buffer, CloneBuf, Device, DevicelessAble,
-    MainMemory, OnDropBuffer, Read, StackArray, WriteBuf, impl_retriever, impl_buffer_hook_traits, Retriever,
+    MainMemory, OnDropBuffer, Read, StackArray, WriteBuf, impl_retriever, impl_buffer_hook_traits,
 };
 
 /// A device that allocates memory on the stack.
@@ -20,20 +20,7 @@ impl Stack {
 }
 
 impl_buffer_hook_traits!(Stack);
-
-impl<T, Mods: OnDropBuffer> Retriever<T> for Stack<Mods> {
-    fn retrieve<S, const NUM_PARENTS: usize>(
-        &self,
-        len: usize,
-        parents: impl crate::Parents<NUM_PARENTS>,
-    ) -> Buffer<T, Self, S>
-    where
-        T: 'static,
-        S: Shape {
-        todo!()
-    }
-}
-// impl_retriever!(Stack);
+impl_retriever!(Stack, Copy + Default);
 
 
 impl<'a, T: Copy + Default, S: Shape> DevicelessAble<'a, T, S> for Stack {}
diff --git a/src/features.rs b/src/features.rs
index 72151db3..8e5cde6f 100644
--- a/src/features.rs
+++ b/src/features.rs
@@ -16,25 +16,23 @@ pub trait Feature: OnDropBuffer {}
 // how to fix this:
 // add retrieved buffer to no grads pool at the end of the chain (at device level (Retriever trait))
 // => "generator", "actor"
-pub trait Retrieve<D, G>: OnDropBuffer {
+pub trait Retrieve<D, T>: OnDropBuffer {
     // "generator"
     #[track_caller]
-    fn retrieve<T, S, const NUM_PARENTS: usize>(
+    fn retrieve<S, const NUM_PARENTS: usize>(
         &self,
         device: &D,
         len: usize,
         parents: impl Parents<NUM_PARENTS>,
     ) -> D::Data<T, S>
     where
-        T: 'static, // if 'static causes any problems -> put T to => Retrieve<D, T>?
         S: Shape,
         D: Device + Alloc<T>;
 
     // "actor"
     #[inline]
-    fn on_retrieve_finish<T, S: Shape>(&self, _retrieved_buf: &Buffer<T, D, S>)
+    fn on_retrieve_finish<S: Shape>(&self, _retrieved_buf: &Buffer<T, D, S>)
     where
-        T: 'static,
         D: Alloc<T>,
     {
     }
diff --git a/src/modules/autograd.rs b/src/modules/autograd.rs
index c2d9f248..ff065943 100644
--- a/src/modules/autograd.rs
+++ b/src/modules/autograd.rs
@@ -119,12 +119,12 @@ impl<Mods: Setup<NewDev>, NewDev> Setup<NewDev> for Autograd<Mods> {
     }
 }
 
-impl<G, Mods: Retrieve<D, G>, D> Retrieve<D, G> for Autograd<Mods>
+impl<T:'static, Mods: Retrieve<D, T>, D> Retrieve<D, T> for Autograd<Mods>
 where
     D: PtrConv + Device + 'static,
 {
     #[inline]
-    fn retrieve<T, S, const NUM_PARENTS: usize>(
+    fn retrieve<S, const NUM_PARENTS: usize>(
         &self,
         device: &D,
         len: usize,
@@ -132,16 +132,14 @@ where
     ) -> <D>::Data<T, S>
     where
         D: Alloc<T>,
-        T: 'static,
         S: crate::Shape,
     {
         self.modules.retrieve(device, len, parents)
     }
 
     #[inline]
-    fn on_retrieve_finish<T, S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
+    fn on_retrieve_finish<S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
     where
-        T: 'static,
         D: Alloc<T>,
     {
         self.register_no_grad_buf(retrieved_buf);
diff --git a/src/modules/base.rs b/src/modules/base.rs
index 714ae951..73b7a81e 100644
--- a/src/modules/base.rs
+++ b/src/modules/base.rs
@@ -40,9 +40,9 @@ impl<T, D: Device, S: Shape> OnNewBuffer<T, D, S> for Base {}
 
 impl OnDropBuffer for Base {}
 
-impl<D, G> Retrieve<D, G> for Base {
+impl<D, T> Retrieve<D, T> for Base {
     #[inline]
-    fn retrieve<T, S, const NUM_PARENTS: usize>(
+    fn retrieve<S, const NUM_PARENTS: usize>(
         &self,
         device: &D,
         len: usize,
diff --git a/src/modules/cached.rs b/src/modules/cached.rs
index 5147b6e6..9a640201 100644
--- a/src/modules/cached.rs
+++ b/src/modules/cached.rs
@@ -63,11 +63,11 @@ impl<Mods: OnDropBuffer, SD: Device> OnDropBuffer for CachedModule<Mods, SD> {
 }
 
 // TODO: a more general OnDropBuffer => "Module"
-impl<G, Mods: Retrieve<D, G>, D: Device + PtrConv<SimpleDevice>, SimpleDevice: Device + PtrConv<D>>
-    Retrieve<D, G> for CachedModule<Mods, SimpleDevice>
+impl<T, Mods: Retrieve<D, T>, D: Device + PtrConv<SimpleDevice>, SimpleDevice: Device + PtrConv<D>>
+    Retrieve<D, T> for CachedModule<Mods, SimpleDevice>
 {
     #[inline]
-    fn retrieve<T, S: Shape, const NUM_PARENTS: usize>(
+    fn retrieve<S: Shape, const NUM_PARENTS: usize>(
         &self,
         device: &D,
         len: usize,
@@ -80,9 +80,8 @@ impl<G, Mods: Retrieve<D, G>, D: Device + PtrConv<SimpleDevice>, SimpleDevice: D
     }
 
     #[inline]
-    fn on_retrieve_finish<T, S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
+    fn on_retrieve_finish<S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
     where
-        T: 'static,
         D: Alloc<T>,
     {
         self.modules.on_retrieve_finish(retrieved_buf)
diff --git a/src/modules/lazy.rs b/src/modules/lazy.rs
index 85dd37fc..33c76b41 100644
--- a/src/modules/lazy.rs
+++ b/src/modules/lazy.rs
@@ -115,16 +115,15 @@ impl<Mods: TapeActions> TapeActions for Lazy<Mods> {
     }
 }
 
-impl<G, Mods: Retrieve<D, G>, D: PtrConv + 'static> Retrieve<D, G> for Lazy<Mods> {
+impl<T: 'static, Mods: Retrieve<D, T>, D: PtrConv + 'static> Retrieve<D, T> for Lazy<Mods> {
     #[inline]
-    fn retrieve<T, S, const NUM_PARENTS: usize>(
+    fn retrieve<S, const NUM_PARENTS: usize>(
         &self,
         device: &D,
         len: usize,
         parents: impl Parents<NUM_PARENTS>,
     ) -> <D>::Data<T, S>
     where
-        T: 'static,
         S: Shape,
         D: Alloc<T>,
     {
@@ -132,9 +131,8 @@ impl<G, Mods: Retrieve<D, G>, D: PtrConv + 'static> Retrieve<D, G> for Lazy<Mods
     }
 
     #[inline]
-    fn on_retrieve_finish<T, S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
+    fn on_retrieve_finish<S: Shape>(&self, retrieved_buf: &Buffer<T, D, S>)
     where
-        T: 'static,
         D: Alloc<T>,
     {
         unsafe { register_buf(&mut self.outs.borrow_mut(), retrieved_buf) };
diff --git a/src/two_way_ops/mod.rs b/src/two_way_ops/mod.rs
index 9f12db43..01cdc2ed 100644
--- a/src/two_way_ops/mod.rs
+++ b/src/two_way_ops/mod.rs
@@ -290,8 +290,8 @@ mod tests {
 
         let a = f(4f32.to_val(), 3f32.to_val());
 
-        // roughly_eq_slices(&[a.eval()], &[22.2]);
-        assert_eq!(a.eval(), 22.2);
+        roughly_eq_slices(&[a.eval()], &[22.2]);
+        // assert_eq!(a.eval(), 22.2);
 
         let r = f("x".to_marker(), "y".to_marker()).to_cl_source();
         assert_eq!("(((x + y) * 3.6) - y)", r);
diff --git a/tests/buffer.rs b/tests/buffer.rs
index bcc8d515..d1260358 100644
--- a/tests/buffer.rs
+++ b/tests/buffer.rs
@@ -127,13 +127,13 @@ fn test_cached_cpu() {
     let mut prev_ptr = None;
 
     for _ in 0..100 {
-        let mut buf: Buffer<f32, _> = device.retrieve::<(), 0>(10, ());
+        let buf: Buffer<f32, _> = device.retrieve::<(), 0>(10, ());
 
         if prev_ptr.is_some() {
-            assert_eq!(prev_ptr, Some(buf.data));
+            assert_eq!(prev_ptr, Some(buf.data.ptr));
         }
 
-        prev_ptr = Some(buf.data);
+        prev_ptr = Some(buf.data.ptr);
         
     }
 }
diff --git a/tests/cache.rs b/tests/cache.rs
index 9f9d8f20..dd040f30 100644
--- a/tests/cache.rs
+++ b/tests/cache.rs
@@ -3,12 +3,16 @@ use std::ptr::null_mut;
 
 #[cfg(feature = "cpu")]
 #[cfg(not(feature = "realloc"))]
-use custos::{range, Buffer, CPU};
+use custos::{Buffer, CPU};
 
 #[cfg(feature = "cpu")]
 #[cfg(not(feature = "realloc"))]
+#[track_caller]
 fn cached_add<'a>(device: &'a CPU, a: &[f32], b: &[f32]) -> Buffer<'a, f32, CPU> {
-    let mut out = custos::Device::retrieve::<f32, ()>(device, 10, ());
+    use custos::Retriever;
+
+    let mut out = device.retrieve(10, ()); 
+    
     for i in 0..out.len() {
         out[i] = a[i] + b[i];
     }
@@ -19,6 +23,8 @@ fn cached_add<'a>(device: &'a CPU, a: &[f32], b: &[f32]) -> Buffer<'a, f32, CPU>
 #[cfg(not(feature = "realloc"))]
 #[test]
 fn test_caching_cpu() {
+    use custos::Base;
+
     let device = CPU::<Base>::new();
 
     let a = Buffer::<f32, _>::new(&device, 100);
@@ -26,14 +32,11 @@ fn test_caching_cpu() {
 
     let mut old_ptr = null_mut();
 
-    for _ in range(100) {
+    for _ in 0..100 {
         let mut out = cached_add(&device, &a, &b);
         if out.host_ptr() != old_ptr && !old_ptr.is_null() {
             panic!("Should be the same pointer!");
         }
         old_ptr = out.host_ptr_mut();
-        let len = device.addons.cache.borrow().nodes.len();
-        //let len = CPU_CACHE.with(|cache| cache.borrow().nodes.len());
-        assert_eq!(len, 3);
     }
 }
diff --git a/tests/caller.rs b/tests/caller.rs
index f1e0d076..09328b6c 100644
--- a/tests/caller.rs
+++ b/tests/caller.rs
@@ -3,7 +3,7 @@ use std::{
     ops::Add,
 };
 
-use custos::{range, Buffer, CacheReturn, Device, CPU};
+use custos::prelude::*;
 
 #[derive(Debug, Default, Clone)]
 pub struct Call {
@@ -27,7 +27,7 @@ impl Add for &Call {
     }
 }
 
-pub fn add<'a, T: Add<Output = T> + Copy>(
+pub fn add<'a, T: Add<Output = T> + Copy + 'static>(
     device: &'a CPU,
     lhs: &Buffer<T>,
     rhs: &Buffer<T>,
@@ -41,36 +41,3 @@ pub fn add<'a, T: Add<Output = T> + Copy>(
 
     out
 }
-
-#[test]
-fn test_caller() {
-    let device = CPU::<Base>::new();
-
-    let lhs = device.buffer([1, 2, 3, 4]);
-    let rhs = device.buffer([1, 2, 3, 4]);
-
-    for _ in range(100) {
-        add(&device, &lhs, &rhs);
-    }
-
-    assert_eq!(device.cache().nodes.len(), 3);
-
-    for _ in 0..100 {
-        add(&device, &lhs, &rhs);
-    }
-
-    assert_eq!(device.cache().nodes.len(), 102);
-
-    let cell = RefCell::new(10);
-
-    let x = cell.borrow();
-    // cell.borrow_mut();
-
-    let caller = Call::default();
-    caller.call();
-
-    let _ = &caller + &Call::default();
-
-    let loc = caller.location;
-    println!("location: {loc:?}");
-}
diff --git a/tests/clear.rs b/tests/clear.rs
index 63e8f59d..eda6a2e3 100644
--- a/tests/clear.rs
+++ b/tests/clear.rs
@@ -6,7 +6,7 @@ use custos_macro::stack_cpu_test;
 #[stack_cpu_test]
 #[test]
 fn test_clear_cpu() {
-    let device = CPU::<Base>::new();
+    let device = CPU::<custos::Base>::new();
 
     let mut buf = Buffer::with(&device, [1., 2., 3., 4., 5., 6.]);
     assert_eq!(buf.read(), [1., 2., 3., 4., 5., 6.,]);
diff --git a/tests/clone_buf.rs b/tests/clone_buf.rs
index a4ca9978..2e0d0e47 100644
--- a/tests/clone_buf.rs
+++ b/tests/clone_buf.rs
@@ -1,8 +1,10 @@
-use custos::{Buffer, CloneBuf, CPU};
+use custos::prelude::*;
 
 #[cfg(feature = "cpu")]
 #[test]
 fn test_buf_clone() {
+    use custos::CloneBuf;
+
     let device = CPU::<Base>::new();
     let buf = Buffer::from((&device, [1., 2., 6., 2., 4.]));
 
diff --git a/tests/dealloc_dev.rs b/tests/dealloc_dev.rs
deleted file mode 100644
index f93966ce..00000000
--- a/tests/dealloc_dev.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use custos::prelude::*;
-
-#[cfg(feature = "cpu")]
-#[test]
-fn test_rc_get_dev() {
-    {
-        let device = CPU::<Base>::new();
-        let mut a = Buffer::from((&device, [1., 2., 3., 4., 5., 6.]));
-
-        for _ in range(100) {
-            a.clear();
-            assert_eq!(&[0.; 6], a.as_slice());
-        }
-    }
-}
-
-#[cfg(feature = "opencl")]
-#[test]
-fn test_dealloc_cl() -> custos::Result<()> {
-    let device = OpenCL::new(0)?;
-
-    let a = Buffer::from((&device, [1f32, 2., 3., 4., 5., 6.]));
-    let b = Buffer::from((&device, [6., 5., 4., 3., 2., 1.]));
-
-    drop(a);
-    drop(b);
-    drop(device);
-
-    Ok(())
-}
-
-#[cfg(feature = "cpu")]
-#[cfg(not(feature = "realloc"))]
-#[test]
-fn test_dealloc_device_cache_cpu() {
-    let device = CPU::<Base>::new();
-
-    assert_eq!(device.cache().nodes.len(), 0);
-    let a = device.retrieve::<f32, ()>(10, ());
-    assert_eq!(device.cache().nodes.len(), 1);
-
-    drop(a);
-    drop(device);
-    //assert_eq!(device.cache.borrow().nodes.len(), 0);
-}
-
-#[cfg(not(feature = "realloc"))]
-#[cfg(feature = "opencl")]
-#[test]
-fn test_dealloc_device_cache_cl() -> custos::Result<()> {
-    let device = OpenCL::new(0)?;
-
-    assert_eq!(device.cache().nodes.len(), 0);
-    let a = device.retrieve::<f32, ()>(10, ());
-    assert_eq!(device.cache().nodes.len(), 1);
-
-    drop(a);
-    drop(device);
-    Ok(())
-}
-
-#[cfg(not(feature = "realloc"))]
-#[cfg(feature = "cuda")]
-#[test]
-fn test_dealloc_device_cache_cu() -> custos::Result<()> {
-    use custos::CUDA;
-
-    let device = CUDA::new(0)?;
-
-    assert_eq!(device.cache().nodes.len(), 0);
-    let a = device.retrieve::<f32, _>(10, ());
-    assert_eq!(device.cache().nodes.len(), 1);
-
-    drop(a);
-    drop(device);
-    Ok(())
-}
diff --git a/tests/for.rs b/tests/for.rs
deleted file mode 100644
index 55997410..00000000
--- a/tests/for.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use custos::range;
-
-#[test]
-fn test_range() {
-    let mut count = 0;
-    for epoch in range(10) {
-        assert_eq!(epoch, count);
-        count += 1;
-    }
-}
-
-#[test]
-fn test_range1() {
-    let mut count = 0;
-    for epoch in range(0..10) {
-        assert_eq!(epoch, count);
-        count += 1;
-        assert!(epoch < 10)
-    }
-}
-
-#[test]
-fn test_range_inclusive() {
-    let mut count = 0;
-    for epoch in range(0..=10) {
-        assert_eq!(epoch, count);
-        count += 1;
-        assert!(epoch < 11)
-    }
-}
diff --git a/tests/shallow.rs b/tests/shallow.rs
index 8073f39f..9017ba79 100644
--- a/tests/shallow.rs
+++ b/tests/shallow.rs
@@ -3,6 +3,8 @@ use custos::{Buffer, CPU};
 #[cfg(feature = "cpu")]
 #[test]
 fn test_shallow_buf_copy() {
+    use custos::Base;
+
     let device = CPU::<Base>::new();
 
     let buf = Buffer::from((&device, [1, 2, 3, 4, 5]));
@@ -29,6 +31,8 @@ fn test_shallow_buf_realloc() {
 #[cfg(not(feature = "realloc"))]
 #[test]
 fn test_shallow_buf_realloc() {
+    use custos::Base;
+
     let device = CPU::<Base>::new();
 
     let buf = Buffer::from((&device, [1, 2, 3, 4, 5]));
diff --git a/tests/threading/threads.rs b/tests/threading/threads.rs
index ce8e9809..1053eea5 100644
--- a/tests/threading/threads.rs
+++ b/tests/threading/threads.rs
@@ -3,6 +3,8 @@ use custos::{Buffer, CPU};
 #[cfg(feature = "cpu")]
 #[test]
 fn test_with_threads() {
+    use custos::Base;
+
     let device = CPU::<Base>::new();
 
     //let buf = Buffer::from((&device, [1, 2, 3, 4]));
diff --git a/tests/write.rs b/tests/write.rs
index 2856be0e..911a3fb2 100644
--- a/tests/write.rs
+++ b/tests/write.rs
@@ -8,7 +8,7 @@ use custos_macro::stack_cpu_test;
 #[stack_cpu_test]
 #[test]
 fn test_write_cpu() {
-    let device = CPU::<Base>::new();
+    let device = CPU::<custos::Base>::new();
     let mut buf: Buffer<_, _, custos::Dim1<5>> = Buffer::new(&device, 5);
     device.write(&mut buf, &[1., 2., 3., 4., 5.]);
     assert_eq!(buf.as_slice(), &[1., 2., 3., 4., 5.])
@@ -17,7 +17,7 @@ fn test_write_cpu() {
 #[cfg(feature = "cpu")]
 #[test]
 fn test_write_buf_cpu() {
-    use custos::{Buffer, WriteBuf, CPU};
+    use custos::{Buffer, WriteBuf, CPU, Base};
 
     let device = CPU::<Base>::new();