diff --git a/luisa_compute/src/lang/soa.rs b/luisa_compute/src/lang/soa.rs
index 6fb6a77..6ce80fa 100644
--- a/luisa_compute/src/lang/soa.rs
+++ b/luisa_compute/src/lang/soa.rs
@@ -1,14 +1,139 @@
+use crate::internal_prelude::*;
 use crate::prelude::*;
-use luisa_compute_ir::ir::Type;
+use crate::runtime::submit_default_stream_and_sync;
+use parking_lot::Mutex;
+use std::ops::RangeBounds;
 use std::sync::Arc;
 
+use crate::runtime::Kernel;
+
+use super::index::IntoIndex;
 use super::types::SoaValue;
 /** A buffer with SOA layout.
  */
 pub struct SoaBuffer<T: SoaValue> {
-    storage: Arc<ByteBuffer>,
-    metadata: Buffer<SoaMetadata>,
-    _marker: std::marker::PhantomData<T>,
+    pub(crate) device: Device,
+    pub(crate) storage: Arc<ByteBuffer>,
+    pub(crate) metadata_buf: Buffer<SoaMetadata>,
+    pub(crate) metadata: SoaMetadata,
+    pub(crate) copy_kernel: Mutex<Option<SoaBufferCopyKernel<T>>>,
+    pub(crate) _marker: std::marker::PhantomData<T>,
+}
+pub(crate) struct SoaBufferCopyKernel<T: SoaValue> {
+    copy_to: Kernel<fn(SoaBuffer<T>, Buffer<T>, u64)>,
+    copy_from: Kernel<fn(SoaBuffer<T>, Buffer<T>, u64)>,
+}
+impl<T: SoaValue> SoaBufferCopyKernel<T> {
+    #[tracked]
+    fn new(device: &Device) -> Self {
+        let copy_to =
+            device.create_kernel::<fn(SoaBuffer<T>, Buffer<T>, u64)>(&|soa, buf, offset| {
+                let i = dispatch_id().x.as_u64() + offset;
+                let v = soa.read(i);
+                buf.write(i, v);
+            });
+        let copy_from =
+            device.create_kernel::<fn(SoaBuffer<T>, Buffer<T>, u64)>(&|soa, buf, offset| {
+                let i = dispatch_id().x.as_u64() + offset;
+                let v = buf.read(i);
+                soa.write(i, v);
+            });
+        Self { copy_to, copy_from }
+    }
+}
+impl<T: SoaValue> SoaBuffer<T> {
+    pub fn var(&self) -> SoaBufferVar<T> {
+        self.view(..).var()
+    }
+    pub fn len(&self) -> usize {
+        self.metadata.count as usize
+    }
+    pub fn len_expr(&self) -> Expr<u64> {
+        self.metadata_buf.read(0).count
+    }
+    pub fn view<S: RangeBounds<usize>>(&self, range: S) -> SoaBufferView<T> {
+        let lower = range.start_bound();
+        let upper = range.end_bound();
+        let lower = match lower {
+            std::ops::Bound::Included(&x) => x,
+            std::ops::Bound::Excluded(&x) => x + 1,
+            std::ops::Bound::Unbounded => 0,
+        };
+        let upper = match upper {
+            std::ops::Bound::Included(&x) => x + 1,
+            std::ops::Bound::Excluded(&x) => x,
+            std::ops::Bound::Unbounded => self.len(),
+        };
+        assert!(lower <= upper);
+        assert!(upper <= self.metadata.count as usize);
+        let metadata = SoaMetadata {
+            count: self.metadata.count,
+            view_start: lower as u64,
+            view_count: (upper - lower) as u64,
+        };
+        SoaBufferView {
+            metadata_buf: self.device.create_buffer_from_slice(&[metadata]),
+            metadata,
+            buffer: self,
+        }
+    }
+    pub fn copy_from_buffer_async(&self, buffer: &Buffer<T>) -> Command<'static, 'static> {
+        self.view(..).copy_from_buffer_async(buffer)
+    }
+    pub fn copy_from_buffer(&self, buffer: &Buffer<T>) {
+        self.view(..).copy_from_buffer(buffer)
+    }
+    pub fn copy_to_buffer_async(&self, buffer: &Buffer<T>) -> Command<'static, 'static> {
+        self.view(..).copy_to_buffer_async(buffer)
+    }
+    pub fn copy_to_buffer(&self, buffer: &Buffer<T>) {
+        self.view(..).copy_to_buffer(buffer)
+    }
+}
+impl<'a, T: SoaValue> SoaBufferView<'a, T> {
+    fn init_copy_kernel(&self) {
+        let mut copy_kernel = self.buffer.copy_kernel.lock();
+        if copy_kernel.is_none() {
+            *copy_kernel = Some(SoaBufferCopyKernel::new(&self.buffer.device));
+        }
+    }
+    pub fn var(&self) -> SoaBufferVar<T> {
+        SoaBufferVar {
+            proxy: T::SoaBuffer::from_soa_storage(
+                self.buffer.storage.var(),
+                self.metadata_buf.read(0),
+                0,
+            ),
+        }
+    }
+    pub fn copy_from_buffer_async(&self, buffer: &Buffer<T>) -> Command<'static, 'static> {
+        self.init_copy_kernel();
+        let copy_kernel = self.buffer.copy_kernel.lock();
+        let copy_kernel = copy_kernel.as_ref().unwrap();
+        copy_kernel.copy_from.dispatch_async(
+            [self.metadata.view_count as u32, 1, 1],
+            self,
+            buffer,
+            &self.metadata.view_start,
+        )
+    }
+    pub fn copy_from_buffer(&self, buffer: &Buffer<T>) {
+        submit_default_stream_and_sync(&self.buffer.device, [self.copy_from_buffer_async(buffer)]);
+    }
+    pub fn copy_to_buffer_async(&self, buffer: &Buffer<T>) -> Command<'static, 'static> {
+        self.init_copy_kernel();
+        let copy_kernel = self.buffer.copy_kernel.lock();
+        let copy_kernel = copy_kernel.as_ref().unwrap();
+        copy_kernel.copy_to.dispatch_async(
+            [self.metadata.view_count as u32, 1, 1],
+            self,
+            buffer,
+            &self.metadata.view_start,
+        )
+    }
+    pub fn copy_to_buffer(&self, buffer: &Buffer<T>) {
+        submit_default_stream_and_sync(&self.buffer.device, [self.copy_to_buffer_async(buffer)]);
+    }
 }
 #[derive(Clone, Copy, Value)]
 #[repr(C)]
@@ -19,28 +144,22 @@ pub struct SoaMetadata {
     pub view_start: u64,
     pub view_count: u64,
 }
-pub(crate) struct SoaStorage {
-    data: Arc<ByteBuffer>,
-}
 pub struct SoaBufferView<'a, T: SoaValue> {
-    metadata: Buffer<SoaMetadata>,
-    buffer: &'a SoaBuffer<T>,
+    pub(crate) metadata_buf: Buffer<SoaMetadata>,
+    pub(crate) metadata: SoaMetadata,
+    pub(crate) buffer: &'a SoaBuffer<T>,
 }
 pub struct SoaBufferVar<T: SoaValue> {
-    proxy: T::SoaBuffer,
+    pub(crate) proxy: T::SoaBuffer,
 }
-
-fn compute_number_of_32bits_buffers(ty: &Type) -> usize {
-    (ty.size() + 3) / 4
+impl<T: SoaValue> IndexRead for SoaBufferVar<T> {
+    type Element = T;
+    fn read<I: IntoIndex>(&self, i: I) -> Expr<Self::Element> {
+        self.proxy.read(i)
+    }
+}
+impl<T: SoaValue> IndexWrite for SoaBufferVar<T> {
+    fn write<I: IntoIndex, V: AsExpr<Value = Self::Element>>(&self, i: I, value: V) {
+        self.proxy.write(i, value)
+    }
 }
-
-// impl<T> IndexRead for SoaBuffer<T>
-// where
-//     T: Value,
-// {
-//     type Element = T;
-//     fn read<I: super::index::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
-//         let i = i.to_u64();
-//         todo!()
-//     }
-// }
diff --git a/luisa_compute/src/lang/types/array.rs b/luisa_compute/src/lang/types/array.rs
index 12897a9..2a92fac 100644
--- a/luisa_compute/src/lang/types/array.rs
+++ b/luisa_compute/src/lang/types/array.rs
@@ -20,6 +20,56 @@ impl<T: Value, const N: usize> ArrayNewExpr<T, N> for [T; N] {
 impl_simple_expr_proxy!([T: Value, const N: usize] ArrayExpr[T, N] for [T; N]);
 impl_simple_var_proxy!([T: Value, const N: usize] ArrayVar[T, N] for [T; N]);
 impl_simple_atomic_ref_proxy!([T: Value, const N: usize] ArrayAtomicRef[T, N] for [T; N]);
+#[derive(Clone)]
+pub struct ArraySoa<T: SoaValue, const N: usize> {
+    pub(crate) elems: Vec<T::SoaBuffer>,
+    _marker: PhantomData<[T; N]>,
+}
+impl<T: SoaValue, const N: usize> SoaValue for [T; N] {
+    type SoaBuffer = ArraySoa<T, N>;
+}
+impl<T: SoaValue, const N: usize> SoaBufferProxy for ArraySoa<T, N> {
+    type Value = [T; N];
+    fn from_soa_storage(
+        storage: ByteBufferVar,
+        meta: Expr<SoaMetadata>,
+        global_offset: usize,
+    ) -> Self {
+        let elems = (0..N)
+            .map(|i| {
+                T::SoaBuffer::from_soa_storage(
+                    storage.clone(),
+                    meta,
+                    global_offset + i * T::SoaBuffer::num_buffers(),
+                )
+            })
+            .collect::<Vec<_>>();
+        Self {
+            elems,
+            _marker: PhantomData,
+        }
+    }
+    fn num_buffers() -> usize {
+        T::SoaBuffer::num_buffers() * N
+    }
+}
+impl<T: SoaValue, const N: usize> IndexRead for ArraySoa<T, N> {
+    type Element = [T; N];
+    fn read<I: IntoIndex>(&self, i: I) -> Expr<Self::Element> {
+        let i = i.to_u64();
+        let elems = (0..N).map(|j| self.elems[j].read(i)).collect::<Vec<_>>();
+        <[T; N]>::from_elems_expr(elems.try_into().unwrap_or_else(|_| unreachable!()))
+    }
+}
+impl<T: SoaValue, const N: usize> IndexWrite for ArraySoa<T, N> {
+    fn write<I: IntoIndex, V: AsExpr<Value = Self::Element>>(&self, i: I, value: V) {
+        let i = i.to_u64();
+        let value = value.as_expr();
+        for j in 0..N {
+            self.elems[j].write(i, value.read(j as u64));
+        }
+    }
+}
 impl<T: Value, const N: usize> ArrayExpr<T, N> {
     pub fn len(&self) -> Expr<u32> {
         (N as u32).expr()
diff --git a/luisa_compute/src/lang/types/core.rs b/luisa_compute/src/lang/types/core.rs
index a7bd886..3f3f05b 100644
--- a/luisa_compute/src/lang/types/core.rs
+++ b/luisa_compute/src/lang/types/core.rs
@@ -1,3 +1,9 @@
+use std::any::TypeId;
+
+use serde_json::value::Index;
+
+use crate::lang::soa::SoaBuffer;
+
 use super::*;
 
 mod private {
@@ -24,6 +30,7 @@ pub trait Primitive: private::Sealed + Copy + TypeOf + 'static {
 /**
  * This is the heart of SOA implementation.
  */
+#[derive(Clone)]
 pub struct PrimitiveSoaProxy<T> {
     /// this soa view starts from (self.global_offset * self.count * 4) of the global bytebuffer
     /// Each primitive must be stored in a 4-aligned region, due to dx12 does not support access <4 aligned values
@@ -36,23 +43,21 @@ pub struct PrimitiveSoaProxy<T> {
     pub(crate) data: ByteBufferVar,
     _marker: std::marker::PhantomData<T>,
 }
-impl<T: Primitive> IndexRead for PrimitiveSoaProxy<T> {
-    type Element = T;
+
+impl IndexRead for PrimitiveSoaProxy<bool> {
+    type Element = bool;
     #[tracked]
     fn read<I: crate::lang::index::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
-        let i = i.to_u64();
-        if need_runtime_check() {
-            lc_assert!(i.lt(self.view_count));
-        }
-        unsafe {
-            self.data.read_as::<T>(
+        let v = unsafe {
+            self.data.read_as::<u32>(
                 self.global_offset * self.count * 4
-                    + (self.view_start + i) * std::mem::size_of::<T>() as u64,
+                    + (self.view_start + i.to_u64()) * std::mem::size_of::<u32>() as u64,
             )
-        }
+        };
+        v.ne(0)
     }
 }
-impl<T: Primitive> IndexWrite for PrimitiveSoaProxy<T> {
+impl IndexWrite for PrimitiveSoaProxy<bool> {
     #[tracked]
     fn write<I: crate::lang::index::IntoIndex, V: AsExpr<Value = Self::Element>>(
         &self,
@@ -61,19 +66,181 @@ impl<T: Primitive> IndexWrite for PrimitiveSoaProxy<T> {
     ) {
         let i = i.to_u64();
         let v = value.as_expr();
-        if need_runtime_check() {
-            lc_assert!(i.lt(self.view_count));
-        }
         unsafe {
-            self.data.write_as::<T>(
+            self.data.write_as::<u32>(
                 self.global_offset * self.count * 4
-                    + (self.view_start + i) * std::mem::size_of::<T>() as u64,
-                v,
+                    + (self.view_start + i) * std::mem::size_of::<u32>() as u64,
+                select(v, 1u32.expr(), 0u32.expr()),
             );
         }
     }
 }
-impl<T: Primitive> SoaBufferProxy for PrimitiveSoaProxy<T> {
+macro_rules! impl_prim_soa_16 {
+    ($T:ty) => {
+        impl IndexRead for PrimitiveSoaProxy<$T> {
+            type Element = $T;
+            #[tracked]
+            fn read<I: crate::lang::index::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
+                let i = i.to_u64();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+
+                unsafe {
+                    let v = self.data.read_as::<u32>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<u32>() as u64,
+                    );
+                    let v = (v & 0xffff).as_u16();
+                    v.bitcast::<$T>()
+                }
+            }
+        }
+        impl IndexWrite for PrimitiveSoaProxy<$T> {
+            #[tracked]
+            fn write<I: crate::lang::index::IntoIndex, V: AsExpr<Value = Self::Element>>(
+                &self,
+                i: I,
+                value: V,
+            ) {
+                let i = i.to_u64();
+                let v = value.as_expr();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+                unsafe {
+                    let v = v.bitcast::<u16>();
+                    let v = v.as_u32();
+                    self.data.write_as::<u32>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<u32>() as u64,
+                        v,
+                    );
+                }
+            }
+        }
+    };
+}
+macro_rules! impl_prim_soa_8 {
+    ($T:ty) => {
+        impl IndexRead for PrimitiveSoaProxy<$T> {
+            type Element = $T;
+            #[tracked]
+            fn read<I: crate::lang::index::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
+                let i = i.to_u64();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+
+                unsafe {
+                    let v = self.data.read_as::<u32>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<u32>() as u64,
+                    );
+                    let v = (v & 0xff).as_u8();
+                    v.bitcast::<$T>()
+                }
+            }
+        }
+        impl IndexWrite for PrimitiveSoaProxy<$T> {
+            #[tracked]
+            fn write<I: crate::lang::index::IntoIndex, V: AsExpr<Value = Self::Element>>(
+                &self,
+                i: I,
+                value: V,
+            ) {
+                let i = i.to_u64();
+                let v = value.as_expr();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+                unsafe {
+                    let v = v.bitcast::<u8>();
+                    let v = v.as_u32();
+                    self.data.write_as::<u32>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<u32>() as u64,
+                        v,
+                    );
+                }
+            }
+        }
+    };
+}
+macro_rules! impl_prim_soa {
+    ($T:ty) => {
+        impl IndexRead for PrimitiveSoaProxy<$T> {
+            type Element = $T;
+            #[tracked]
+            fn read<I: crate::lang::index::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
+                let i = i.to_u64();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+
+                assert!(std::mem::align_of::<$T>() >= 4);
+                unsafe {
+                    self.data.read_as::<$T>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<$T>() as u64,
+                    )
+                }
+            }
+        }
+        impl IndexWrite for PrimitiveSoaProxy<$T> {
+            #[tracked]
+            fn write<I: crate::lang::index::IntoIndex, V: AsExpr<Value = Self::Element>>(
+                &self,
+                i: I,
+                value: V,
+            ) {
+                let i = i.to_u64();
+                let v = value.as_expr();
+                if need_runtime_check() {
+                    lc_assert!(i.lt(self.view_count));
+                }
+                unsafe {
+                    self.data.write_as::<$T>(
+                        self.global_offset * self.count * 4
+                            + (self.view_start + i) * std::mem::size_of::<$T>() as u64,
+                        v,
+                    );
+                }
+            }
+        }
+    };
+}
+impl_prim_soa_8!(u8);
+impl_prim_soa_8!(i8);
+impl_prim_soa_16!(u16);
+impl_prim_soa_16!(i16);
+impl_prim_soa_16!(f16);
+impl_prim_soa!(f32);
+impl_prim_soa!(f64);
+impl_prim_soa!(i32);
+impl_prim_soa!(i64);
+impl_prim_soa!(u32);
+impl_prim_soa!(u64);
+#[allow(dead_code)]
+#[allow(unreachable_code)]
+fn check_soa_impl() {
+    let _bool: SoaBuffer<bool> = unimplemented!();
+    let _f16: SoaBuffer<f16> = unimplemented!();
+    let _f32: SoaBuffer<f32> = unimplemented!();
+    let _f64: SoaBuffer<f64> = unimplemented!();
+    let _i8: SoaBuffer<i8> = unimplemented!();
+    let _i16: SoaBuffer<i16> = unimplemented!();
+    let _i32: SoaBuffer<i32> = unimplemented!();
+    let _i64: SoaBuffer<i64> = unimplemented!();
+    let _u8: SoaBuffer<u8> = unimplemented!();
+    let _u16: SoaBuffer<u16> = unimplemented!();
+    let _u32: SoaBuffer<u32> = unimplemented!();
+    let _u64: SoaBuffer<u64> = unimplemented!();
+}
+impl<T: Primitive> SoaBufferProxy for PrimitiveSoaProxy<T>
+where
+    Self: IndexRead<Element = T> + IndexWrite,
+{
     type Value = T;
     fn from_soa_storage(
         storage: ByteBufferVar,
@@ -103,7 +270,10 @@ impl<T: Primitive> Value for T {
         Expr::<Self>::from_node(node)
     }
 }
-impl<T: Primitive> SoaValue for T {
+impl<T: Primitive> SoaValue for T
+where
+    PrimitiveSoaProxy<T>: IndexWrite + IndexRead<Element = T>,
+{
     type SoaBuffer = PrimitiveSoaProxy<T>;
 }
 
diff --git a/luisa_compute/src/lib.rs b/luisa_compute/src/lib.rs
index 9cda3bb..ade93e6 100644
--- a/luisa_compute/src/lib.rs
+++ b/luisa_compute/src/lib.rs
@@ -35,7 +35,7 @@ pub mod prelude {
     };
     pub use crate::lang::types::vector::swizzle::*;
     pub use crate::lang::types::vector::VectorExprProxy;
-    pub use crate::lang::types::{AsExpr, Expr, Value, Var};
+    pub use crate::lang::types::{AsExpr, Expr, Value, Var, SoaValue};
     pub use crate::lang::Aggregate;
     pub use crate::resource::{IoTexel, StorageTexel, *};
     pub use crate::runtime::api::StreamTag;
@@ -60,7 +60,7 @@ mod internal_prelude {
     };
     pub(crate) use crate::lang::ops::Linear;
     pub(crate) use crate::lang::types::vector::alias::*;
-    pub(crate) use crate::lang::types::vector::*;
+    pub(crate) use crate::lang::types::{SoaBufferProxy, vector::*};
     #[allow(unused_imports)]
     pub(crate) use crate::lang::{
         check_index_lt_usize, ir, CallFuncTrait, Recorder, __compose, __extract, __insert,
@@ -86,8 +86,7 @@ pub use {luisa_compute_backend as backend, luisa_compute_sys as sys};
 
 use lazy_static::lazy_static;
 use luisa_compute_backend::Backend;
-use parking_lot::lock_api::RawMutex as RawMutexTrait;
-use parking_lot::{Mutex, RawMutex};
+use parking_lot::Mutex;
 use runtime::{Device, DeviceHandle, StreamHandle};
 use std::collections::HashMap;
 use std::sync::Weak;
diff --git a/luisa_compute/src/resource.rs b/luisa_compute/src/resource.rs
index 654d20f..8bf9b66 100644
--- a/luisa_compute/src/resource.rs
+++ b/luisa_compute/src/resource.rs
@@ -323,7 +323,9 @@ impl Drop for BufferHandle {
 #[derive(Clone, Copy)]
 pub struct BufferView<'a, T: Value> {
     pub(crate) buffer: &'a Buffer<T>,
+    /// offset in #elements
     pub(crate) offset: usize,
+    /// length in #elements
     pub(crate) len: usize,
 }
 impl<'a, T: Value> BufferView<'a, T> {
diff --git a/luisa_compute/src/runtime.rs b/luisa_compute/src/runtime.rs
index 8bdf0ac..8ce842f 100644
--- a/luisa_compute/src/runtime.rs
+++ b/luisa_compute/src/runtime.rs
@@ -16,7 +16,7 @@ use raw_window_handle::HasRawWindowHandle;
 use winit::window::Window;
 
 use crate::internal_prelude::*;
-use crate::lang::soa::SoaBuffer;
+use crate::lang::soa::{SoaBuffer, SoaBufferVar, SoaBufferView, SoaMetadata};
 use crate::lang::types::SoaValue;
 use ir::{
     CallableModule, CallableModuleRef, Capture, CpuCustomOp, KernelModule, Module, ModuleFlags,
@@ -197,8 +197,25 @@ impl Device {
         buffer
     }
     pub fn create_soa_buffer<T: SoaValue>(&self, count: usize) -> SoaBuffer<T> {
+        assert!(count <= u32::MAX as usize, "count must be less than u32::MAX. This limitation may be removed in the future.");
         // let inner = self.create_byte_buffer(len)
-        todo!()
+        let num_buffers = T::SoaBuffer::num_buffers();
+        let storage = Arc::new(self.create_byte_buffer(count * num_buffers * std::mem::size_of::<u32>()));
+        let metadata = SoaMetadata {
+            count: count as u64,
+            view_start: 0,
+            view_count: count as u64,
+        };
+        let metadata_buf = self.create_buffer_from_slice(&[metadata]);
+        let buffer = SoaBuffer {
+            storage,
+            metadata_buf,
+            metadata,
+            _marker: PhantomData,
+            copy_kernel: Mutex::new(None),
+            device: self.clone(),
+        };
+        buffer
     }
     pub fn create_buffer<T: Value>(&self, count: usize) -> Buffer<T> {
         let name = self.name();
@@ -1014,10 +1031,18 @@ impl KernelArgEncoder {
             size: buffer.len * std::mem::size_of::<T>(),
         }));
     }
+    pub fn soa_buffer<T: SoaValue>(&mut self, buffer: &SoaBuffer<T>) {
+        self.buffer(&buffer.storage);
+        self.buffer(&buffer.metadata_buf);
+    }
+    pub fn soa_buffer_view<T: SoaValue>(&mut self, view: &SoaBufferView<T>) {
+        self.buffer(view.buffer.storage.as_ref());
+        self.buffer::<SoaMetadata>(&view.buffer.metadata_buf);
+    }
     pub fn buffer_view<T: Value>(&mut self, buffer: &BufferView<T>) {
         self.args.push(api::Argument::Buffer(api::BufferArgument {
             buffer: buffer.handle(),
-            offset: buffer.offset,
+            offset: buffer.offset* std::mem::size_of::<T>(),
             size: buffer.len * std::mem::size_of::<T>(),
         }));
     }
@@ -1067,6 +1092,18 @@ impl<T: Value> KernelArg for Buffer<T> {
         encoder.buffer(self);
     }
 }
+impl<T:SoaValue> KernelArg for SoaBuffer<T> {
+    type Parameter = SoaBufferVar<T>;
+    fn encode(&self, encoder: &mut KernelArgEncoder) {
+        encoder.soa_buffer(self);
+    }
+}
+impl<'a, T:SoaValue> KernelArg for SoaBufferView<'a, T> {
+    type Parameter = SoaBufferVar<T>;
+    fn encode(&self, encoder: &mut KernelArgEncoder) {
+        encoder.soa_buffer_view(self);
+    }
+}
 // impl KernelArg for ByteBuffer {
 //     type Parameter = ByteBufferVar;
 //     fn encode(&self, encoder: &mut KernelArgEncoder) {
@@ -1396,7 +1433,12 @@ impl<T: Value> AsKernelArg for Buffer<T> {
 impl<'a, T: Value> AsKernelArg for BufferView<'a, T> {
     type Output = Buffer<T>;
 }
-
+impl<T: SoaValue> AsKernelArg for SoaBuffer<T> {
+    type Output = SoaBuffer<T>;
+}
+impl<'a, T: SoaValue> AsKernelArg for SoaBufferView<'a, T> {
+    type Output = SoaBuffer<T>;
+}
 impl<'a, T: IoTexel> AsKernelArg for Tex2dView<'a, T> {
     type Output = Tex2d<T>;
 }
diff --git a/luisa_compute/src/runtime/kernel.rs b/luisa_compute/src/runtime/kernel.rs
index 283180b..72b1d38 100644
--- a/luisa_compute/src/runtime/kernel.rs
+++ b/luisa_compute/src/runtime/kernel.rs
@@ -1,3 +1,5 @@
+use crate::lang::soa::SoaMetadata;
+
 use super::*;
 
 impl<T: Value> CallableParameter for Expr<T> {
@@ -129,7 +131,12 @@ impl<T: Value> KernelParameter for BufferVar<T> {
         builder.buffer()
     }
 }
-
+impl<T: SoaValue> KernelParameter for SoaBufferVar<T> {
+    type Arg = SoaBuffer<T>;
+    fn def_param(builder: &mut KernelBuilder) -> Self {
+        builder.soa_buffer()
+    }
+}
 // impl KernelParameter for ByteBufferVar {
 //     type Arg = ByteBuffer;
 //     fn def_param(builder: &mut KernelBuilder) -> Self {
@@ -244,6 +251,13 @@ impl KernelBuilder {
             handle: None,
         }
     }
+    pub fn soa_buffer<T: SoaValue>(&mut self) -> SoaBufferVar<T> {
+        let storage = self.buffer::<u8>();
+        let metadata = self.buffer::<SoaMetadata>();
+        SoaBufferVar{
+            proxy: T::SoaBuffer::from_soa_storage(storage, metadata.read(0), 0)
+        }
+    }
     pub fn tex2d<T: IoTexel>(&mut self) -> Tex2dVar<T> {
         let node = new_node(
             __module_pools(),
@@ -338,7 +352,6 @@ impl KernelBuilder {
         })
     }
 
-
     /// Don't use this directly
     /// See [`Callable`] for how to create a callable
     #[doc(hidden)]
diff --git a/luisa_compute/tests/misc.rs b/luisa_compute/tests/misc.rs
index ceab4f2..ecbadd7 100644
--- a/luisa_compute/tests/misc.rs
+++ b/luisa_compute/tests/misc.rs
@@ -896,6 +896,49 @@ fn buffer_u8() {
     kernel.dispatch([1024, 1, 1]);
 }
 #[test]
+fn buffer_view_copy() {
+    let device = get_device();
+    let n = 1024;
+    let buf = device.create_buffer::<f32>(n);
+    let first_half = buf.view(0..n / 2);
+    let second_half = buf.view(n / 2..);
+    first_half.fill_fn(|i| i as f32);
+    second_half.fill_fn(|i| -(i as f32));
+    let data = buf.copy_to_vec();
+    for i in 0..n {
+        if i < n / 2 {
+            assert_eq!(data[i], i as f32);
+        } else {
+            assert_eq!(data[i], -((i - n / 2) as f32));
+        }
+    }
+}
+#[test]
+fn buffer_view() {
+    let device = get_device();
+    let n = 1024;
+    let buf = device.create_buffer::<f32>(n);
+    let first_half = buf.view(0..n / 2);
+    let second_half = buf.view(n / 2..);
+    let kernel = Kernel::<fn(Buffer<f32>, Buffer<f32>)>::new(
+        &device,
+        &track!(|a, b| {
+            let tid = dispatch_id().x;
+            a.write(tid, tid.as_f32());
+            b.write(tid, -tid.as_f32());
+        }),
+    );
+    kernel.dispatch([n as u32 / 2, 1, 1], &first_half, &second_half);
+    let data = buf.copy_to_vec();
+    for i in 0..n {
+        if i < n / 2 {
+            assert_eq!(data[i], i as f32);
+        } else {
+            assert_eq!(data[i], -((i - n / 2) as f32));
+        }
+    }
+}
+#[test]
 fn byte_buffer() {
     let device = get_device();
     let buf = device.create_byte_buffer(1024);
@@ -1130,7 +1173,7 @@ fn is_nan() {
 //     track!(*a + b)
 // }
 
-#[derive(Clone, Copy, Debug, Value, PartialEq)]
+#[derive(Clone, Copy, Debug, Value, Soa, PartialEq)]
 #[repr(C)]
 #[value_new(pub)]
 pub struct Foo {
@@ -1138,7 +1181,23 @@ pub struct Foo {
     v: Float2,
     a: [i32; 4],
 }
-
+#[test]
+fn soa() {
+    let device = get_device();
+    let mut rng = thread_rng();
+    let foos = device.create_buffer_from_fn(1024, |_| Foo {
+        i: rng.gen(),
+        v: Float2::new(rng.gen(), rng.gen()),
+        a: [rng.gen(), rng.gen(), rng.gen(), rng.gen()],
+    });
+    let foos_soa = device.create_soa_buffer::<Foo>(1024);
+    foos_soa.copy_from_buffer(&foos);
+    let also_foos = device.create_buffer(1024);
+    foos_soa.copy_to_buffer(&also_foos);
+    let foos_data = foos.view(..).copy_to_vec();
+    let also_foos_data = also_foos.view(..).copy_to_vec();
+    assert_eq!(foos_data, also_foos_data);
+}
 #[test]
 fn atomic() {
     let device = get_device();
diff --git a/luisa_compute_derive_impl/src/lib.rs b/luisa_compute_derive_impl/src/lib.rs
index 95b5734..3887d6a 100644
--- a/luisa_compute_derive_impl/src/lib.rs
+++ b/luisa_compute_derive_impl/src/lib.rs
@@ -155,56 +155,54 @@ impl Compiler {
         let field_types: Vec<_> = fields.iter().map(|f| &f.ty).collect();
         let field_names: Vec<_> = fields.iter().map(|f| f.ident.as_ref().unwrap()).collect();
         let soa_proxy_name = syn::Ident::new(&format!("{}Soa", name), name.span());
-        quote_spanned!(span=>{
-            #[repr(C)]
-            #[derive(Copy, Clone)]
-            pub struct #soa_proxy_name #generics #where_clause{
-                #(#field_vis #field_names: <#field_types as #lang_path::SoaValue>::SoaBuffer),*
+        quote_spanned!(span=>
+            #[derive(Clone)]
+            #vis struct #soa_proxy_name #generics #where_clause{
+                #(#field_vis #field_names: <#field_types as #lang_path::types::SoaValue>::SoaBuffer),*
             }
-            impl #impl_generics #lang_path::SoaValue for #name #ty_generics #where_clause{
+            impl #impl_generics #lang_path::types::SoaValue for #name #ty_generics #where_clause{
                 type SoaBuffer = #soa_proxy_name #ty_generics;
             }
-            impl #impl_generics #lang_path::SoaBufferProxy for #soa_proxy_name #ty_generics #where_clause{
+            impl #impl_generics #lang_path::types::SoaBufferProxy for #soa_proxy_name #ty_generics #where_clause{
                 type Value = #name #ty_generics;
 
                 #[allow(unused_assignments)]
                 fn from_soa_storage(
-                    storage: ByteBufferVar,
-                    meta: Expr<SoaMetadata>,
-                    global_offset: usize,
+                    ___storage: ::luisa_compute::resource::ByteBufferVar,
+                    ___meta: Expr<#lang_path::soa::SoaMetadata>,
+                    ___global_offset: usize,
                 ) -> Self {
-                    use #lang_path::SoaBufferProxy;
-                    let mut i = 0;
+                    use #lang_path::types::SoaBufferProxy;
+                    let mut ___i = 0usize;
                     #(
-                        let $field_names = T::SoaBuffer::from_soa_storage(
-                            storage.clone(),
-                            meta.clone(),
-                            global_offset + i,
+                        let #field_names = <#field_types as #lang_path::types::SoaValue>::SoaBuffer::from_soa_storage(
+                            ___storage.clone(),
+                            ___meta.clone(),
+                            ___global_offset + ___i,
                         );
-                        i += <#field_types::SoaBuffer as SoaBufferProxy>::num_buffers();
+                        ___i += <<#field_types as #lang_path::types::SoaValue>::SoaBuffer as #lang_path::types::SoaBufferProxy>::num_buffers();
                     )*
                     Self{
                         #(#field_names),*
                     }
                 }
                 fn num_buffers() -> usize {
-                    [#( <#field_types as #lang_path::SoaValue>::SoaBuffer::num_buffers()),*].iter().sum()
+                    [#( <#field_types as #lang_path::types::SoaValue>::SoaBuffer::num_buffers()),*].iter().sum()
                 }
             }
-            impl #impl_generics #lang_path::IndexRead for #soa_proxy_name #ty_generics #where_clause{
+            impl #impl_generics #lang_path::index::IndexRead for #soa_proxy_name #ty_generics #where_clause{
                 type Element = #name #ty_generics;
-                fn read<I:#lang_path::IntoIndex>(&self, i: I) -> Expr<Self::Element> {
-                    let i = i.to_u64();
+                fn read<I:#lang_path::index::IntoIndex>(&self, ___i: I) -> #lang_path::types::Expr<Self::Element> {
+                    let ___i = ___i.to_u64();
+                    use #lang_path::FromNode;
                     #(
-                        let #field_names = self.#field_names.read(i);
+                        let #field_names = self.#field_names.read(___i);
                     )*
-                    Self{
-                        #(#field_names),*
-                    }
+                    Expr::<Self::Element>::from_node(#lang_path::__compose::<Self::Element>(&[ #( #lang_path::ToNode::node(&#field_names) ),* ]))
                 }
             }
-            impl #impl_generics #lang_path::IndexWrite for #soa_proxy_name #ty_generics #where_clause{
-                fn write<I:#lang_path::IntoIndex, V: #lang_path::AsExpr<Value = Self::Element>>(&self, i: I, value: V) {
+            impl #impl_generics #lang_path::index::IndexWrite for #soa_proxy_name #ty_generics #where_clause{
+                fn write<I:#lang_path::index::IntoIndex, V: #lang_path::types::AsExpr<Value = Self::Element>>(&self, i: I, value: V) {
                     let i = i.to_u64();
                     let v = value.as_expr();
                     #(
@@ -212,7 +210,7 @@ impl Compiler {
                     )*
                 }
             }
-        })
+        )
     }
     pub fn derive_value(&self, struct_: &ItemStruct) -> TokenStream {
         let ordering = self.value_attributes(&struct_.attrs);
diff --git a/luisa_compute_sys/LuisaCompute b/luisa_compute_sys/LuisaCompute
index 6887785..46d8999 160000
--- a/luisa_compute_sys/LuisaCompute
+++ b/luisa_compute_sys/LuisaCompute
@@ -1 +1 @@
-Subproject commit 688778557bf4fe6cb87f0d3cd3caf0dd3259d880
+Subproject commit 46d89997f6495156083d6cf2d138c50442c708d1