diff --git a/Cargo.lock b/Cargo.lock
index ef14850..747a4f2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -664,7 +664,9 @@ dependencies = [
  "guillotiere",
  "half",
  "image",
+ "ktx2",
  "rectangle-pack",
+ "ruzstd",
  "serde",
  "thiserror 2.0.12",
  "tracing",
@@ -962,6 +964,7 @@ dependencies = [
  "image",
  "indexmap",
  "js-sys",
+ "ktx2",
  "naga",
  "naga_oil",
  "nonmax",
@@ -2441,6 +2444,15 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
+[[package]]
+name = "ktx2"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87d65e08a9ec02e409d27a0139eaa6b9756b4d81fe7cde71f6941a83730ce838"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
 [[package]]
 name = "lalrpop"
 version = "0.22.1"
@@ -3593,6 +3605,15 @@ dependencies = [
  "unicode-script",
 ]
 
+[[package]]
+name = "ruzstd"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3640bec8aad418d7d03c72ea2de10d5c646a598f9883c7babc160d91e3c1b26c"
+dependencies = [
+ "twox-hash",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.20"
@@ -4063,6 +4084,12 @@ version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c591d83f69777866b9126b24c6dd9a18351f177e49d625920d19f989fd31cf8"
 
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
 [[package]]
 name = "typeid"
 version = "1.0.3"
diff --git a/Cargo.toml b/Cargo.toml
index 9c445b0..8cf5be3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,6 +68,9 @@ features = [
   "x11",
   "bevy_winit",
   "bevy_window",
+  "tonemapping_luts",
+  "ktx2",
+  "zstd",
 ]
 
 [[example]]
@@ -81,3 +84,6 @@ name = "one_shot"
 
 [[example]]
 name = "boids"
+
+[[example]]
+name = "shared_storage"
diff --git a/assets/shaders/shared_storage_compute.wgsl b/assets/shaders/shared_storage_compute.wgsl
new file mode 100644
index 0000000..906b712
--- /dev/null
+++ b/assets/shaders/shared_storage_compute.wgsl
@@ -0,0 +1,17 @@
+@group(0) @binding(0)
+var<uniform> time: f32;
+
+@group(0) @binding(1)
+var<storage, read_write> heights: array<f32>;
+
+@compute @workgroup_size(1)
+fn main(@builtin(global_invocation_id) invocation_id: vec3<u32>) {
+    let idx = invocation_id.x;
+    if (idx < 121u) {
+        let grid_size = 11u;
+        let x = f32(idx % grid_size);
+        let z = f32(idx / grid_size);
+        
+        heights[idx] = sin(x * 0.5 + time) * cos(z * 0.5 + time) * 0.1;
+    }
+}
diff --git a/assets/shaders/shared_storage_vertex.wgsl b/assets/shaders/shared_storage_vertex.wgsl
new file mode 100644
index 0000000..bc99939
--- /dev/null
+++ b/assets/shaders/shared_storage_vertex.wgsl
@@ -0,0 +1,58 @@
+#import bevy_pbr::{
+    mesh_functions,
+    view_transformations::position_world_to_clip,
+    forward_io::{Vertex, VertexOutput},
+}
+
+@group(2) @binding(100) 
+var<storage, read> heights: array<f32>;
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+    var out: VertexOutput;
+
+    let local_pos = vertex.position;
+
+    let grid_size = 11u;
+    let x_index = u32(vertex.uv.x * f32(grid_size - 1u));
+    let z_index = u32(vertex.uv.y * f32(grid_size - 1u));
+    let height_index = z_index * grid_size + x_index;
+    
+    let height = heights[height_index];
+
+    var modified_position = local_pos;
+    modified_position.y += height;
+
+    let world_from_local = mesh_functions::get_world_from_local(vertex.instance_index);
+    out.world_position = mesh_functions::mesh_position_local_to_world(
+        world_from_local, 
+        vec4<f32>(modified_position, 1.0)
+    );
+    out.position = position_world_to_clip(out.world_position.xyz);
+
+    // compute normals from adjacent heights
+    let hL = heights[max(0u, height_index - 1u)];
+    let hR = heights[min(120u, height_index + 1u)];
+    let hD = heights[max(0u, height_index - grid_size)];
+    let hU = heights[min(120u, height_index + grid_size)];
+    
+    let normal = normalize(vec3<f32>(hL - hR, 2.0, hD - hU));
+    
+    out.world_normal = mesh_functions::mesh_normal_local_to_world(
+        normal,
+        vertex.instance_index
+    );
+    
+    out.uv = vertex.uv;
+    out.instance_index = vertex.instance_index;
+
+    #ifdef VERTEX_TANGENTS
+        out.world_tangent = mesh_functions::mesh_tangent_local_to_world(
+            world_from_local,
+            vertex.tangent,
+            vertex.instance_index
+        );
+    #endif
+
+    return out;
+}
diff --git a/examples/boids/worker.rs b/examples/boids/worker.rs
index 77d11e0..9bb55ba 100644
--- a/examples/boids/worker.rs
+++ b/examples/boids/worker.rs
@@ -70,6 +70,7 @@ impl ComputeWorker for BoidWorker {
             .add_pass::<BoidsShader>(
                 [NUM_BOIDS / 64, 1, 1],
                 &["params", "boids_src", "boids_dst"],
+                &[],
             )
             .add_swap("boids_src", "boids_dst")
             .build()
diff --git a/examples/game_of_life/worker.rs b/examples/game_of_life/worker.rs
index 8f3a5a4..936fc55 100644
--- a/examples/game_of_life/worker.rs
+++ b/examples/game_of_life/worker.rs
@@ -68,6 +68,7 @@ impl ComputeWorker for GameOfLifeWorker {
                     1,
                 ],
                 &[SETTINGS_BUFFER, CELLS_IN_BUFFER, CELLS_OUT_BUFFER],
+                &[]
             )
             .add_swap(CELLS_IN_BUFFER, CELLS_OUT_BUFFER)
             .build()
diff --git a/examples/multi_pass.rs b/examples/multi_pass.rs
index b051665..0d9d320 100644
--- a/examples/multi_pass.rs
+++ b/examples/multi_pass.rs
@@ -31,8 +31,8 @@ impl ComputeWorker for SimpleComputeWorker {
             .add_uniform("value", &3.)
             .add_storage("input", &[1., 2., 3., 4.])
             .add_staging("output", &[0f32; 4])
-            .add_pass::<FirstPassShader>([4, 1, 1], &["value", "input", "output"]) // add each item + `value` from `input` to `output`
-            .add_pass::<SecondPassShader>([4, 1, 1], &["output"]) // multiply each element of `output` by itself
+            .add_pass::<FirstPassShader>([4, 1, 1], &["value", "input", "output"], &[]) // add each item + `value` from `input` to `output`
+            .add_pass::<SecondPassShader>([4, 1, 1], &["output"], &[]) // multiply each element of `output` by itself
             .build();
 
         // [1. + 3., 2. + 3., 3. + 3., 4. + 3.] = [4., 5., 6., 7.]
diff --git a/examples/one_shot.rs b/examples/one_shot.rs
index bc46bd4..6a058eb 100644
--- a/examples/one_shot.rs
+++ b/examples/one_shot.rs
@@ -20,7 +20,7 @@ impl ComputeWorker for SimpleComputeWorker {
         let worker = AppComputeWorkerBuilder::new(world)
             .add_uniform("uni", &5.)
             .add_staging("values", &[1., 2., 3., 4.])
-            .add_pass::<SimpleShader>([4, 1, 1], &["uni", "values"])
+            .add_pass::<SimpleShader>([4, 1, 1], &["uni", "values"], &[])
             .one_shot()
             .build();
 
diff --git a/examples/shared_storage.rs b/examples/shared_storage.rs
new file mode 100644
index 0000000..0cf8c8b
--- /dev/null
+++ b/examples/shared_storage.rs
@@ -0,0 +1,116 @@
+use bevy::{
+    pbr::{ExtendedMaterial, MaterialExtension, StandardMaterial},
+    prelude::*,
+    render::{render_resource::AsBindGroup, storage::ShaderStorageBuffer},
+};
+use bevy_app_compute::prelude::*;
+use tracing::info;
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+struct SharedStorageMaterial {
+    #[storage(100, read_only)]
+    heights: Handle<ShaderStorageBuffer>,
+}
+
+impl MaterialExtension for SharedStorageMaterial {
+    fn vertex_shader() -> ShaderRef {
+        "shaders/shared_storage_vertex.wgsl".into()
+    }
+}
+
+#[derive(TypePath)]
+struct SharedStorageComputeShader;
+
+impl ComputeShader for SharedStorageComputeShader {
+    fn shader() -> ShaderRef {
+        "shaders/shared_storage_compute.wgsl".into()
+    }
+}
+
+#[derive(Resource)]
+struct SimpleSharedStorageComputeWorker;
+
+impl ComputeWorker for SimpleSharedStorageComputeWorker {
+    fn build(world: &mut World) -> AppComputeWorker<Self> {
+        let heights = vec![0.0f32; 121];
+        let worker = AppComputeWorkerBuilder::new(world)
+            .add_uniform("time", &0.0f32)
+            // This allows us to retrieve a `Handle<ShaderStorageBuffer>` which gets shared between the compute shader and the material on the GPU.
+            .add_rw_storage_asset("heights", &heights)
+            .add_pass::<SharedStorageComputeShader>([121, 1, 1], &["time"], &["heights"])
+            .build();
+        worker
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(MaterialPlugin::<
+            ExtendedMaterial<StandardMaterial, SharedStorageMaterial>,
+        >::default())
+        .add_plugins(AppComputePlugin)
+        .add_plugins(AppComputeWorkerPlugin::<SimpleSharedStorageComputeWorker>::default())
+        .add_systems(Startup, startup_system)
+        .add_systems(
+            Update,
+            (
+                spawn_mesh_system
+                    .run_if(resource_added::<AppComputeWorker<SimpleSharedStorageComputeWorker>>),
+                update_shared_storage_time_system
+                    .run_if(resource_exists::<AppComputeWorker<SimpleSharedStorageComputeWorker>>),
+            ),
+        )
+        .run();
+}
+
+fn startup_system(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    commands.spawn((
+        DirectionalLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_rotation(Quat::from_euler(EulerRot::XYZ, -0.5, -0.5, 0.0)),
+    ));
+}
+
+fn spawn_mesh_system(
+    mut commands: Commands,
+    worker: Res<AppComputeWorker<SimpleSharedStorageComputeWorker>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, SharedStorageMaterial>>>,
+) {
+    if let Some(heights_handle) = worker.get_storage_buffer_asset_handle("heights") {
+        let mesh = meshes.add(Plane3d::default().mesh().size(4.0, 4.0).subdivisions(10));
+
+        let material = materials.add(ExtendedMaterial {
+            base: StandardMaterial {
+                base_color: Color::srgb(0.3, 0.7, 0.3),
+                ..default()
+            },
+            extension: SharedStorageMaterial {
+                heights: heights_handle.clone(),
+            },
+        });
+
+        commands.spawn((
+            Mesh3d(mesh),
+            MeshMaterial3d(material),
+            Transform::from_xyz(0.0, 0.0, 0.0),
+        ));
+
+        info!("Terrain mesh spawned");
+    }
+}
+
+fn update_shared_storage_time_system(
+    time: Res<Time>,
+    mut worker: ResMut<AppComputeWorker<SimpleSharedStorageComputeWorker>>,
+) {
+    worker.write("time", &time.elapsed_secs());
+}
diff --git a/examples/simple.rs b/examples/simple.rs
index ec5cee5..70dfa08 100644
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -20,7 +20,7 @@ impl ComputeWorker for SimpleComputeWorker {
         let worker = AppComputeWorkerBuilder::new(world)
             .add_uniform("uni", &5.)
             .add_staging("values", &[1., 2., 3., 4.])
-            .add_pass::<SimpleShader>([4, 1, 1], &["uni", "values"])
+            .add_pass::<SimpleShader>([4, 1, 1], &["uni", "values"], &[])
             .build();
 
         worker
diff --git a/src/error.rs b/src/error.rs
index 91d050b..ea508e3 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,6 +4,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 pub enum Error {
     BufferNotFound(String),
     StagingBufferNotFound(String),
+    StorageAssetHandleNotFound(String),
     InvalidStep(String),
     PipelinesEmpty,
     PipelineNotReady,
@@ -17,6 +18,9 @@ impl std::fmt::Display for Error {
         match self {
             Error::BufferNotFound(name) => write!(f, "Buffer {name} not found."),
             Error::StagingBufferNotFound(name) => write!(f, "Staging buffer {name} not found."),
+            Error::StorageAssetHandleNotFound(name) => {
+                write!(f, "Storage buffer asset handle {name} not found.")
+            }
             Error::PipelinesEmpty => {
                 write!(f, "Missing pipelines. Have you added your shader plugins?")
             }
diff --git a/src/lib.rs b/src/lib.rs
index 37bcd7b..55d452d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,6 +16,7 @@ mod plugin;
 mod traits;
 mod worker;
 mod worker_builder;
+mod storage_buffers;
 
 /// Helper module to import most used elements.
 pub mod prelude {
diff --git a/src/plugin.rs b/src/plugin.rs
index 6fdf703..05d94cd 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -2,11 +2,11 @@ use std::marker::PhantomData;
 
 use bevy::{
     prelude::*,
-    render::renderer::{RenderAdapter, RenderDevice},
+    render::{render_asset::RenderAssets, renderer::{RenderAdapter, RenderDevice}, storage::GpuShaderStorageBuffer, RenderApp},
 };
 
 use crate::{
-    extract_shaders, pipeline_cache::PipelineCache, traits::ComputeWorker, worker::AppComputeWorker,
+    extract_shaders, pipeline_cache::PipelineCache, storage_buffers::extract_gpu_storage_buffers_to_main, traits::ComputeWorker, worker::AppComputeWorker
 };
 
 /// The main plugin. Always include it if you want to use `bevy_app_compute`
@@ -29,6 +29,13 @@ impl Plugin for AppComputePlugin {
                 PipelineCache::process_pipeline_queue_system
                     .in_set(BevyEasyComputeSet::ExtractPipelines),
             );
+
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+            render_app.add_systems(
+                ExtractSchedule,
+                extract_gpu_storage_buffers_to_main.run_if(resource_changed::<RenderAssets<GpuShaderStorageBuffer>>),
+            );
+        }
     }
 }
 
diff --git a/src/storage_buffers.rs b/src/storage_buffers.rs
new file mode 100644
index 0000000..c418ba5
--- /dev/null
+++ b/src/storage_buffers.rs
@@ -0,0 +1,64 @@
+//! GPU storage buffer extraction utilities.
+//!
+//! # Background
+//!
+//! Bevy allows users to define storage buffers on custom materials via the
+//! `#[storage]` attribute on properties with type [`Handle<ShaderStorageBuffer>`].
+//! However, Bevy maps this handle to a [`Buffer`] in the render world.
+//!
+//! The problem is that `bevy_app_compute` was designed to run in the main world,
+//! so we need to extract [`Buffer`]s back to the main world. The bulk of the actual
+//! data sits on the GPU though, so we're really just cloning handles around.
+
+use bevy::{
+    platform::collections::HashMap,
+    prelude::*,
+    render::{
+        MainWorld,
+        render_asset::RenderAssets,
+        render_resource::Buffer,
+        storage::{GpuShaderStorageBuffer, ShaderStorageBuffer},
+    },
+};
+
+/// GPU buffers created via [`ShaderStorageBuffer`] assets, available in the main world.
+///
+/// This is essentially [`RenderAssets<GpuShaderStorageBuffer>`] but extracted to
+/// the main world so compute workers can access prepared GPU buffers.
+#[derive(Resource, Default)]
+pub struct MainWorldShaderStorageBufferAssets {
+    buffers: HashMap<AssetId<ShaderStorageBuffer>, Buffer>,
+}
+
+impl MainWorldShaderStorageBufferAssets {
+    /// Gets the GPU buffer for the given asset ID.
+    pub fn get(&self, id: &AssetId<ShaderStorageBuffer>) -> Option<&Buffer> {
+        self.buffers.get(id)
+    }
+
+    /// Inserts a GPU buffer for the given asset ID.
+    pub(crate) fn insert(&mut self, id: AssetId<ShaderStorageBuffer>, buffer: Buffer) {
+        self.buffers.insert(id, buffer);
+    }
+}
+
+/// Extracts GPU storage buffers from the render world to the main world.
+///
+/// This system runs in the render app's [`ExtractSchedule`] and copies buffer
+/// handles (not data) to make them accessible to compute workers in the main world.
+///
+/// Note: Cloning [`Buffer`] is cheap as it only clones a handle/reference to the
+/// GPU resource, not the actual GPU memory.
+pub(crate) fn extract_gpu_storage_buffers_to_main(
+    mut main_world: ResMut<MainWorld>,
+    gpu_buffers: Res<RenderAssets<GpuShaderStorageBuffer>>,
+) {
+    let mut main_buffers = MainWorldShaderStorageBufferAssets::default();
+
+    for (id, gpu_buffer) in gpu_buffers.iter() {
+        // Cloning Buffer is cheap - it's just a handle to GPU memory
+        main_buffers.insert(id.clone(), gpu_buffer.buffer.clone());
+    }
+
+    main_world.insert_resource(main_buffers);
+}
diff --git a/src/worker.rs b/src/worker.rs
index 5b8e49a..068d130 100644
--- a/src/worker.rs
+++ b/src/worker.rs
@@ -6,21 +6,20 @@ use std::{
 };
 
 use bevy::{
-    platform::collections::HashMap,
-    prelude::{Res, ResMut, Resource},
-    render::{
+    asset::Handle, platform::collections::HashMap, prelude::{Res, ResMut, Resource}, render::{
         render_resource::{Buffer, ComputePipeline},
-        renderer::{RenderDevice, RenderQueue},
-    },
+        renderer::{RenderDevice, RenderQueue}, storage::ShaderStorageBuffer,
+    }
 };
 use bytemuck::{AnyBitPattern, NoUninit, bytes_of, cast_slice, from_bytes};
 use wgpu::{BindGroupEntry, CommandEncoder, CommandEncoderDescriptor, ComputePassDescriptor};
 
 use crate::{
-    error::{Error, Result},
+    error::{Error, Result}, 
     pipeline_cache::{AppCachedComputePipelineId, PipelineCache},
-    traits::ComputeWorker,
-    worker_builder::AppComputeWorkerBuilder,
+    storage_buffers::MainWorldShaderStorageBufferAssets, 
+    traits::ComputeWorker, 
+    worker_builder::AppComputeWorkerBuilder
 };
 
 #[derive(PartialEq, Clone, Copy)]
@@ -43,10 +42,16 @@ pub(crate) enum Step {
     Swap(String, String),
 }
 
+#[derive(Clone,Debug)]
+pub(crate) enum BufferLabel {
+    Worker(String),
+    StorageAsset(String),
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct ComputePass {
     pub(crate) workgroups: [u32; 3],
-    pub(crate) vars: Vec<String>,
+    pub(crate) vars: Vec<BufferLabel>,
     pub(crate) shader_type_path: String,
 }
 
@@ -71,6 +76,7 @@ pub struct AppComputeWorker<W: ComputeWorker> {
     pipelines: HashMap<String, Option<ComputePipeline>>,
     buffers: HashMap<String, Buffer>,
     staging_buffers: HashMap<String, StagingBuffer>,
+    storage_buffer_asset_handles: HashMap<String, Handle<ShaderStorageBuffer>>,
     steps: Vec<Step>,
     command_encoder: Option<CommandEncoder>,
     run_mode: RunMode,
@@ -105,6 +111,7 @@ impl<W: ComputeWorker> From<&AppComputeWorkerBuilder<'_, W>> for AppComputeWorke
             pipelines,
             buffers: builder.buffers.clone(),
             staging_buffers: builder.staging_buffers.clone(),
+            storage_buffer_asset_handles: builder.storage_buffer_asset_handles.clone(),
             steps: builder.steps.clone(),
             command_encoder,
             run_mode: builder.run_mode,
@@ -117,7 +124,7 @@ impl<W: ComputeWorker> From<&AppComputeWorkerBuilder<'_, W>> for AppComputeWorke
 
 impl<W: ComputeWorker> AppComputeWorker<W> {
     #[inline]
-    fn dispatch(&mut self, index: usize) -> Result<()> {
+    fn dispatch(&mut self, index: usize, storage_buffer_assets: &Option<Res<MainWorldShaderStorageBufferAssets>>) -> Result<()> {
         let compute_pass = match &self.steps[index] {
             Step::ComputePass(compute_pass) => compute_pass,
             Step::Swap(_, _) => return Err(Error::InvalidStep(format!("{:?}", self.steps[index]))),
@@ -125,16 +132,37 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
 
         let mut entries = vec![];
         for (index, var) in compute_pass.vars.iter().enumerate() {
-            let Some(buffer) = self.buffers.get(var) else {
-                return Err(Error::BufferNotFound(var.to_owned()));
-            };
-
-            let entry = BindGroupEntry {
-                binding: index as u32,
-                resource: buffer.as_entire_binding(),
-            };
-
-            entries.push(entry);
+            match var {
+                BufferLabel::Worker(name) => {
+                    let Some(buffer) = self.buffers.get(name) else {
+                        return Err(Error::BufferNotFound(name.to_owned()));
+                    };
+                    entries.push(BindGroupEntry {
+                        binding: index as u32,
+                        resource: buffer.as_entire_binding(),
+                    });
+                }
+                BufferLabel::StorageAsset(name) => {
+                    let Some(asset_handle) = self.storage_buffer_asset_handles.get(name) else {
+                        return Err(Error::StorageAssetHandleNotFound(name.to_owned()));
+                    };
+                    
+                    let Some(storage_buffer_assets) = storage_buffer_assets else {
+                        // Probably hasn't been inserted yet
+                        return Ok(());
+                    };
+
+                    let Some(buffer) = storage_buffer_assets.get(&asset_handle.id()) else {
+                        // Probably the asset exists but hasn't been prepared yet
+                        return Ok(());
+                    };
+
+                    entries.push(BindGroupEntry {
+                        binding: index as u32,
+                        resource: buffer.as_entire_binding(),
+                    });
+                }
+            }
         }
 
         let Some(maybe_pipeline) = self.pipelines.get(&compute_pass.shader_type_path) else {
@@ -399,7 +427,7 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
             && (self.run_mode != RunMode::OneShot(false))
     }
 
-    pub(crate) fn run(mut worker: ResMut<Self>) {
+    pub(crate) fn run(mut worker: ResMut<Self>, storage_buffers: Option<Res<MainWorldShaderStorageBufferAssets>>) {
         if worker.ready() {
             worker.state = WorkerState::Available;
         }
@@ -408,7 +436,7 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
             // Workaround for interior mutability
             for i in 0..worker.steps.len() {
                 let result = match worker.steps[i] {
-                    Step::ComputePass(_) => worker.dispatch(i),
+                    Step::ComputePass(_) => worker.dispatch(i, &storage_buffers),
                     Step::Swap(_, _) => worker.swap(i),
                 };
 
@@ -476,4 +504,8 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
     pub fn get_buffer(&self, target: &str) -> Option<&Buffer> {
         self.buffers.get(target)
     }
+
+    pub fn get_storage_buffer_asset_handle(&self, target: &str) -> Option<&Handle<ShaderStorageBuffer>> {
+        self.storage_buffer_asset_handles.get(target)
+    }
 }
diff --git a/src/worker_builder.rs b/src/worker_builder.rs
index 50203a4..4fbb1c5 100644
--- a/src/worker_builder.rs
+++ b/src/worker_builder.rs
@@ -1,22 +1,19 @@
 use std::{borrow::Cow, marker::PhantomData, time::Duration};
 
 use bevy::{
-    platform::collections::HashMap,
-    prelude::{AssetServer, World},
-    render::{
+    asset::{Assets, Handle}, platform::collections::HashMap, prelude::{AssetServer, World}, render::{
         render_resource::{
-            Buffer, ComputePipelineDescriptor, ShaderRef, ShaderType,
-            encase::{StorageBuffer, UniformBuffer, private::WriteInto},
+            encase::{private::WriteInto, StorageBuffer, UniformBuffer}, Buffer, ComputePipelineDescriptor, ShaderRef, ShaderType
         },
-        renderer::RenderDevice,
-    },
+        renderer::RenderDevice, storage::ShaderStorageBuffer,
+    }
 };
 use wgpu::{BufferDescriptor, BufferUsages, util::BufferInitDescriptor};
 
 use crate::{
     pipeline_cache::{AppCachedComputePipelineId, PipelineCache},
     traits::{ComputeShader, ComputeWorker},
-    worker::{AppComputeWorker, ComputePass, RunMode, StagingBuffer, Step},
+    worker::{AppComputeWorker, BufferLabel, ComputePass, RunMode, StagingBuffer, Step},
 };
 
 /// A builder struct to build [`AppComputeWorker<W>`]
@@ -26,6 +23,7 @@ pub struct AppComputeWorkerBuilder<'a, W: ComputeWorker> {
     pub(crate) cached_pipeline_ids: HashMap<String, AppCachedComputePipelineId>,
     pub(crate) buffers: HashMap<String, Buffer>,
     pub(crate) staging_buffers: HashMap<String, StagingBuffer>,
+    pub(crate) storage_buffer_asset_handles: HashMap<String, Handle<ShaderStorageBuffer>>,
     pub(crate) steps: Vec<Step>,
     pub(crate) run_mode: RunMode,
     /// Maximum duration the compute shader will run asyncronously before being set to synchronous.
@@ -48,6 +46,7 @@ impl<'a, W: ComputeWorker> AppComputeWorkerBuilder<'a, W> {
             cached_pipeline_ids: HashMap::default(),
             buffers: HashMap::default(),
             staging_buffers: HashMap::default(),
+            storage_buffer_asset_handles: HashMap::default(),
             steps: vec![],
             run_mode: RunMode::Continuous,
             maximum_async_time: Some(Duration::from_secs(0)),
@@ -130,6 +129,54 @@ impl<'a, W: ComputeWorker> AppComputeWorkerBuilder<'a, W> {
         self
     }
 
+    /// Add a new storage buffer to the worker, and fill it with `storage`. It will be read only.
+    /// Additionally, it will create a `ShaderStorageBuffer` asset in the asset server
+    /// which can be shared with materials.
+    pub fn add_storage_asset<T: ShaderType + WriteInto>(
+        &mut self,
+        name: &'static str,
+        storage: &T,
+    ) -> &mut Self {
+        let mut assets = self.world.resource_mut::<Assets<ShaderStorageBuffer>>();
+
+        let mut asset = ShaderStorageBuffer::from(storage);
+        
+        asset.buffer_description.label = Some(name);
+        
+        asset.buffer_description.usage = BufferUsages::COPY_DST | BufferUsages::STORAGE;
+        if let Some(extra_usages) = self.extra_buffer_usages {
+            asset.buffer_description.usage |= extra_usages;
+        }
+
+        let handle = assets.add(asset);
+        self.storage_buffer_asset_handles.insert(name.to_owned(), handle);
+        self
+    }
+
+    /// Add a new storage buffer to the worker, and fill it with `storage`. It will be read only.
+    /// Additionally, it will create a `ShaderStorageBuffer` asset in the asset server
+    /// which can be shared with materials.
+    pub fn add_rw_storage_asset<T: ShaderType + WriteInto>(
+        &mut self,
+        name: &'static str,
+        storage: &T,
+    ) -> &mut Self {
+        let mut assets = self.world.resource_mut::<Assets<ShaderStorageBuffer>>();
+
+        let mut asset = ShaderStorageBuffer::from(storage);
+        
+        asset.buffer_description.label = Some(name);
+        
+        asset.buffer_description.usage = BufferUsages::COPY_DST | BufferUsages::COPY_SRC | BufferUsages::STORAGE;
+        if let Some(extra_usages) = self.extra_buffer_usages {
+            asset.buffer_description.usage |= extra_usages;
+        }
+
+        let handle = assets.add(asset);
+        self.storage_buffer_asset_handles.insert(name.to_owned(), handle);
+        self
+    }
+
     /// Create two staging buffers, one to read from and one to write to.
     /// Additionally, it will create a read/write storage buffer to access from
     /// your shaders.
@@ -247,7 +294,7 @@ impl<'a, W: ComputeWorker> AppComputeWorkerBuilder<'a, W> {
 
     /// Add a new compute pass to your worker.
     /// They will run sequentially in the order you insert them.
-    pub fn add_pass<S: ComputeShader>(&mut self, workgroups: [u32; 3], vars: &[&str]) -> &mut Self {
+    pub fn add_pass<S: ComputeShader>(&mut self, workgroups: [u32; 3], vars: &[&str], storage_asset_vars: &[&str]) -> &mut Self {
         if !self.cached_pipeline_ids.contains_key(S::type_path()) {
             let pipeline_cache = self.world.resource::<PipelineCache>();
 
@@ -277,7 +324,16 @@ impl<'a, W: ComputeWorker> AppComputeWorkerBuilder<'a, W> {
 
         self.steps.push(Step::ComputePass(ComputePass {
             workgroups,
-            vars: vars.iter().map(|a| String::from(*a)).collect(),
+            vars: {
+                let mut v = Vec::with_capacity(vars.len() + storage_asset_vars.len());
+                for var in vars {
+                    v.push(BufferLabel::Worker(var.to_string()));
+                }
+                for var in storage_asset_vars {
+                    v.push(BufferLabel::StorageAsset(var.to_string()));
+                }
+                v
+            },
             shader_type_path: S::type_path().to_string(),
         }));
         self
diff --git a/tests/simple_test.rs b/tests/simple_test.rs
index 296ba44..c45c554 100644
--- a/tests/simple_test.rs
+++ b/tests/simple_test.rs
@@ -22,7 +22,7 @@ impl ComputeWorker for SimpleComputeWorker {
         let worker = AppComputeWorkerBuilder::new(world)
             .add_uniform("uni", &5.)
             .add_staging(INPUT_BUFFER_NAME, &[1., 2., 3., 4.])
-            .add_pass::<SimpleShader>([4, 1, 1], &["uni", INPUT_BUFFER_NAME])
+            .add_pass::<SimpleShader>([4, 1, 1], &["uni", INPUT_BUFFER_NAME], &[])
             .build();
 
         worker