diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 115dd2b..d3a968e 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -1,107 +1,44 @@
-on: [push, pull_request]
+name: CI
 
-name: Continuous integration
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
 
-jobs:
-  check_bevy_audio:
-    name: check bevy_audio
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Install alsa and udev
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
-
-  test_bevy_audio:
-    name: test bevy_audio
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Install alsa and udev
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
+env:
+  CARGO_TERM_COLOR: always
 
-  check_kira:
-    name: check kira
-    runs-on: ubuntu-latest
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        feature: [bevy_audio, kira, oddio] 
+        os: [windows-latest, ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-      - name: Install alsa and udev
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-      - uses: actions-rs/cargo@v1
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
         with:
-          command: check
-          args: --no-default-features --features kira
-
-  test_kira:
-    name: test kira
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-build-${{ matrix.toolchain }}-${{ hashFiles('**/Cargo.toml') }}
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
           toolchain: stable
           override: true
       - name: Install alsa and udev
         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+        if: runner.os == 'linux'
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --no-default-features --features kira
-  
-  # check_oddio:
-  #   name: check oddio
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #     - uses: actions-rs/toolchain@v1
-  #       with:
-  #         profile: minimal
-  #         toolchain: stable
-  #         override: true
-  #     - name: Install alsa and udev
-  #       run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-  #     - uses: actions-rs/cargo@v1
-  #       with:
-  #         command: check
-  #         args: --no-default-features --features oddio
-
-  # test_oddio:
-  #   name: test oddio
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #     - uses: actions-rs/toolchain@v1
-  #       with:
-  #         profile: minimal
-  #         toolchain: stable
-  #         override: true
-  #     - name: Install alsa and udev
-  #       run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-  #     - uses: actions-rs/cargo@v1
-  #       with:
-  #         command: test
-  #         args: --no-default-features --features oddio
+          args: --no-default-features --features ${{ matrix.feature }}
 
   fmt:
     name: fmt
@@ -138,3 +75,22 @@ jobs:
         with:
           command: clippy
           args: -- -D warnings
+
+  miri:
+    name: miri
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        feature: [bevy_audio, kira, oddio] 
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Miri
+        run: |
+          rustup toolchain install nightly --component miri
+          rustup override set nightly
+          cargo miri setup
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - name: Test with Miri
+        run: cargo miri test --no-default-features --features ${{ matrix.feature }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..65fa299
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,41 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 14-11-2022
+
+Reworked the majority of the internals.
+
+## Added
+
+- A way to play streaming DSP sources. See `SourceType::Dynamic`.
+- You can play DSP sources using `Audio::play_dsp`.
+- Two iterators on streaming audio sources: `Iter` and `IterMono`.
+
+### Changed
+
+- Adding the DSP plugin.
+  - You must now call `DspPlugin::default()`.
+- The method on adding DSP sources.
+  - No more initializing using `DspAssets`!
+  - Just add your DSP function using `app.add_dsp_source`
+- Playing DSP sources require `Audio` to be mutable. (Use `ResMut`)
+- A lot of internals are shuffled around.
+
+### Removed
+
+- `DspAssets`. Initialize DSP graphs using `App::add_dsp_source` instead.
+- `FnDspGraph`. This is now reworked to the trait `DspGraph` and can work with any type now.
+- `StreamingDspSource`. This is now reworked to `Iter` (`bevy_kira_audio` and `bevy_oddio`) and `IterMono` (`bevy_audio`). 
+
+## [0.1.0] - 01-08-22
+
+- New bevy plugin! `bevy_fundsp` integrates fundsp with bevy.
+
+[Unreleased]: https://github.com/harudagondi/bevy_fundsp/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/harudagondi/bevy_fundsp/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/harudagondi/bevy_fundsp/releases/tag/v0.1.0
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index f472392..b97ecd2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "bevy_fundsp"
 authors = ["Gio Genre De Asis"]
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "A Bevy plugin that integrates FunDSP into Bevy."
 homepage = "https://github.com/harudagondi/bevy_fundsp"
@@ -12,36 +12,52 @@ categories = ["game-development", "multimedia::audio"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+default = ["bevy_audio"]
+kira = ["dep:kira", "bevy_kira_audio"]
+bevy_audio = ["bevy/bevy_audio", "bevy/wav", "rodio"]
+oddio = ["bevy_oddio"]
+
 [dependencies]
 fundsp = "0.9"
-kira = { version = "0.6", default-features = false, features = ["wav"], optional = true }
-# bevy_oddio = { git = "https://github.com/harudagondi/bevy_oddio.git", optional = true }
+cpal = "0.14"
+once_cell = "1.13"
+rodio = { version = "0.16", default-features = false, features = ["wav"], optional = true }
+kira = { version = "0.7", default-features = false, features = ["wav"], optional = true }
+ringbuf = "0.3"
+parking_lot = "0.12"
 
-atomic = "0.5"
+[dependencies.uuid]
+version = "1.1"
+features = [
+  "v5"
+]
 
 [dependencies.bevy]
 # git = "https://github.com/bevyengine/bevy"
-version = "0.8"
+version = "0.9"
 default-features = false 
 features = ["bevy_asset"]
 
 [dependencies.bevy_kira_audio]
 # git = "https://github.com/NiklasEi/bevy_kira_audio.git"
 # branch = "bevy_main"
-version = "0.11"
+version = "0.13"
 default-features = false
 features = ["wav"]
 optional = true
 
-[features]
-default = ["bevy_audio"]
-kira = ["dep:kira", "bevy_kira_audio"]
-bevy_audio = ["bevy/bevy_audio", "bevy/wav"]
-# oddio = ["bevy_oddio"]
+[dependencies.bevy_oddio]
+# git = "https://github.com/harudagondi/bevy_oddio"
+# branch = "bevy_main"
+version = "0.3"
+default-features = false
+optional = true
+features = ["wav"]
 
 [dev-dependencies.bevy]
 # git = "https://github.com/bevyengine/bevy"
-version = "0.8"
+version = "0.9"
 default-features = false
 features = [
   "render",
@@ -76,7 +92,17 @@ name = "kira_interactive"
 path = "examples/kira/interactive.rs"
 required-features = ["kira"]
 
-# [[example]]
-# name = "oddio_noise"
-# path = "examples/oddio/noise.rs"
-# required-features = ["oddio"]
\ No newline at end of file
+[[example]]
+name = "oddio_noise"
+path = "examples/oddio/noise.rs"
+required-features = ["oddio"]
+
+[[example]]
+name = "oddio_interactive"
+path = "examples/oddio/interactive.rs"
+required-features = ["oddio"]
+
+[[example]]
+name = "oddio_controlled"
+path = "examples/oddio/controlled.rs"
+required-features = ["oddio"]
\ No newline at end of file
diff --git a/README.md b/README.md
index 941ac52..535304d 100644
--- a/README.md
+++ b/README.md
@@ -20,18 +20,15 @@ or multiplying your DSP graph with a low constant (lower than 1.0).
 ```rust no_run
 #![allow(clippy::precedence)]
 
-use bevy_fundsp::prelude::*;
 use bevy::prelude::*;
+use bevy_fundsp::prelude::*;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_plugin(DspPlugin)
-        .add_startup_system(init_dsp)
-        .add_startup_system_to_stage(
-            StartupStage::PostStartup,
-            play_noise
-        )
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(white_noise, SourceType::Dynamic)
+        .add_startup_system_to_stage(StartupStage::PostStartup, play_noise)
         .run();
 }
 
@@ -39,23 +36,26 @@ fn white_noise() -> impl AudioUnit32 {
     white() >> split::<U2>() * 0.2
 }
 
-fn init_dsp(mut dsp_manager: ResMut<DspManager>) {
-    dsp_manager.add_graph(white_noise, 30.0); // length is in seconds
-}
-
-fn play_noise(dsp_assets: Res<DspAssets>, audio: Res<Audio>) {
-    let white_noise = dsp_assets.graph(&white_noise);
-    audio.play(white_noise.clone());
+fn play_noise(
+    mut assets: ResMut<Assets<DspSource>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio<DspSource>>,
+) {
+    let source = dsp_manager
+        .get_graph(white_noise)
+        .unwrap_or_else(|| panic!("DSP source not found!"));
+    audio.play_dsp(assets.as_mut(), source);
 }
 
 ```
 
 ## Compatibility
 
-| `bevy_fundsp` | `bevy` | `bevy_kira_audio`          | `fundsp` |
-| ------------- | ------ | -------------------------- | -------- |
-| main          | main   | main, branch = `bevy_main` | main     |
-| 0.1.0         | 0.8    | 0.11                       | 0.6      |
+| `bevy_fundsp` | `bevy` | `bevy_kira_audio` | `bevy_oddio` | `fundsp` |
+| ------------- | ------ | ----------------- | ------------ | -------- |
+| bevy_main     | main   | bevy_main         | bevy_main    | main     |
+| 0.2.0         | 0.9    | 0.13              | 0.3          | 0.8      |
+| 0.1.0         | 0.8    | 0.11              |              | 0.6      |
 
 ## License
 
diff --git a/examples/bevy_audio/interactive.rs b/examples/bevy_audio/interactive.rs
index ab48b72..9f462dc 100644
--- a/examples/bevy_audio/interactive.rs
+++ b/examples/bevy_audio/interactive.rs
@@ -6,8 +6,9 @@ use bevy_fundsp::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_plugin(DspPlugin)
-        .add_startup_system(init_dsp)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(sine_wave, SourceType::Static { duration: 0.5 })
+        .add_dsp_source(triangle_wave, SourceType::Static { duration: 0.5 })
         .add_system(interactive_audio)
         .run();
 }
@@ -22,19 +23,20 @@ fn triangle_wave() -> impl AudioUnit32 {
     triangle_hz(392.0) >> split::<U2>() * 0.2
 }
 
-fn init_dsp(mut dsp_manager: ResMut<DspManager>) {
-    // length is in seconds
-    dsp_manager
-        .add_graph(sine_wave, 5.0)
-        .add_graph(triangle_wave, 5.0);
-}
-
-fn interactive_audio(input: Res<Input<KeyCode>>, dsp_assets: Res<DspAssets>, audio: Res<Audio>) {
+fn interactive_audio(
+    input: Res<Input<KeyCode>>,
+    mut assets: ResMut<Assets<AudioSource>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio>,
+) {
     if input.just_pressed(KeyCode::S) {
-        audio.play(dsp_assets.graph(&sine_wave));
+        audio.play_dsp(assets.as_mut(), dsp_manager.get_graph(sine_wave).unwrap());
     }
 
     if input.just_pressed(KeyCode::T) {
-        audio.play(dsp_assets.graph(&triangle_wave));
+        audio.play_dsp(
+            assets.as_mut(),
+            dsp_manager.get_graph(triangle_wave).unwrap(),
+        );
     }
 }
diff --git a/examples/bevy_audio/noise.rs b/examples/bevy_audio/noise.rs
index d2efded..8c3ed03 100644
--- a/examples/bevy_audio/noise.rs
+++ b/examples/bevy_audio/noise.rs
@@ -6,8 +6,8 @@ use bevy_fundsp::prelude::*;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_plugin(DspPlugin)
-        .add_startup_system(init_dsp)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(white_noise, SourceType::Dynamic)
         .add_startup_system_to_stage(StartupStage::PostStartup, play_noise)
         .run();
 }
@@ -16,17 +16,13 @@ fn white_noise() -> impl AudioUnit32 {
     white() >> split::<U2>() * 0.2
 }
 
-fn init_dsp(mut dsp_manager: NonSendMut<DspManager>) {
-    dsp_manager.add_graph(white_noise, 30.0); // length is in seconds
-}
-
-fn play_noise(dsp_assets: Res<DspAssets>, audio: Res<Audio>) {
-    let white_noise = dsp_assets.get_graph(white_noise).unwrap();
-    audio.play_with_settings(
-        white_noise.clone(),
-        PlaybackSettings {
-            repeat: true,
-            ..Default::default()
-        },
-    );
+fn play_noise(
+    mut assets: ResMut<Assets<DspSource>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio<DspSource>>,
+) {
+    let source = dsp_manager
+        .get_graph(white_noise)
+        .unwrap_or_else(|| panic!("DSP source not found!"));
+    audio.play_dsp(assets.as_mut(), source);
 }
diff --git a/examples/kira/interactive.rs b/examples/kira/interactive.rs
index 9f36f72..e81f288 100644
--- a/examples/kira/interactive.rs
+++ b/examples/kira/interactive.rs
@@ -2,14 +2,15 @@
 
 use bevy::prelude::*;
 use bevy_fundsp::prelude::*;
-use bevy_kira_audio::*;
+use bevy_kira_audio::prelude::*;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(AudioPlugin)
-        .add_plugin(DspPlugin)
-        .add_startup_system(init_dsp)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(sine_wave, SourceType::Static { duration: 0.5 })
+        .add_dsp_source(triangle_wave, SourceType::Static { duration: 0.5 })
         .add_system(interactive_audio)
         .run();
 }
@@ -24,23 +25,27 @@ fn triangle_wave() -> impl AudioUnit32 {
     triangle_hz(392.0) >> split::<U2>() * 0.2
 }
 
-fn init_dsp(mut dsp_manager: ResMut<DspManager>) {
-    // length is in seconds
-    dsp_manager
-        .add_graph(sine_wave, 5.0)
-        .add_graph(triangle_wave, 5.0);
-}
-
-fn interactive_audio(input: Res<Input<KeyCode>>, dsp_assets: Res<DspAssets>, audio: Res<Audio>) {
+fn interactive_audio(
+    input: Res<Input<KeyCode>>,
+    mut assets: ResMut<Assets<AudioSource>>,
+    dsp_manager: Res<DspManager>,
+    audio: ResMut<Audio>,
+) {
     if input.just_pressed(KeyCode::S) {
-        audio.play_looped(dsp_assets.graph(&sine_wave));
+        let source = dsp_manager
+            .get_graph(sine_wave)
+            .unwrap_or_else(|| panic!("DSP source not found!"));
+        let audio_source = DefaultBackend::convert_to_audio_source(source.clone());
+        let audio_source = assets.add(audio_source);
+        audio.play(audio_source);
     }
 
     if input.just_pressed(KeyCode::T) {
-        audio.play_looped(dsp_assets.graph(&triangle_wave));
-    }
-
-    if input.just_pressed(KeyCode::P) {
-        audio.stop();
+        let source = dsp_manager
+            .get_graph(triangle_wave)
+            .unwrap_or_else(|| panic!("DSP source not found!"));
+        let audio_source = DefaultBackend::convert_to_audio_source(source.clone());
+        let audio_source = assets.add(audio_source);
+        audio.play(audio_source);
     }
 }
diff --git a/examples/kira/noise.rs b/examples/kira/noise.rs
index 7b025c7..7f32f28 100644
--- a/examples/kira/noise.rs
+++ b/examples/kira/noise.rs
@@ -2,14 +2,14 @@
 
 use bevy::prelude::*;
 use bevy_fundsp::prelude::*;
-use bevy_kira_audio::*;
+use bevy_kira_audio::prelude::*;
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(AudioPlugin)
-        .add_plugin(DspPlugin)
-        .add_startup_system(init_dsp)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(white_noise, SourceType::Static { duration: 60.0 })
         .add_startup_system_to_stage(StartupStage::PostStartup, play_noise)
         .run();
 }
@@ -18,11 +18,15 @@ fn white_noise() -> impl AudioUnit32 {
     white() >> split::<U2>() * 0.2
 }
 
-fn init_dsp(mut dsp_manager: NonSendMut<DspManager>) {
-    dsp_manager.add_graph(white_noise, 30.0); // length is in seconds
-}
-
-fn play_noise(dsp_assets: Res<DspAssets>, audio: Res<Audio>) {
-    let white_noise = dsp_assets.get_graph(white_noise).unwrap();
-    audio.play_looped(white_noise.clone());
+fn play_noise(
+    mut assets: ResMut<Assets<AudioSource>>,
+    dsp_manager: Res<DspManager>,
+    audio: ResMut<Audio>,
+) {
+    let source = dsp_manager
+        .get_graph(white_noise)
+        .unwrap_or_else(|| panic!("DSP source not found!"));
+    let audio_source = DefaultBackend::convert_to_audio_source(source.clone());
+    let audio_source = assets.add(audio_source);
+    audio.play(audio_source);
 }
diff --git a/examples/oddio/controlled.rs b/examples/oddio/controlled.rs
new file mode 100644
index 0000000..eb2e8a6
--- /dev/null
+++ b/examples/oddio/controlled.rs
@@ -0,0 +1,52 @@
+#![allow(clippy::precedence)]
+
+use bevy::prelude::*;
+use bevy_fundsp::{dsp_source, prelude::*};
+use bevy_oddio::{frames::Stereo, output::AudioSink, Audio, AudioPlugin};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(AudioPlugin)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(sine_wave, SourceType::Dynamic)
+        .add_startup_system_to_stage(StartupStage::PostStartup, play_sine)
+        .add_system(change_pitch)
+        .run();
+}
+
+const FREQUENCY_ID: i64 = 0;
+
+fn sine_wave() -> impl AudioUnit32 {
+    tag(FREQUENCY_ID, 440.0) >> sine() >> split::<U2>() * 0.2
+}
+
+#[derive(Resource)]
+struct SineSink(Handle<AudioSink<DspSource>>);
+
+fn play_sine(
+    mut assets: ResMut<Assets<DspSource>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio<Stereo, DspSource>>,
+    mut commands: Commands,
+) {
+    let source = dsp_manager
+        .get_graph(sine_wave)
+        .unwrap_or_else(|| panic!("DSP source not found!"));
+    let sink = audio.play_dsp(assets.as_mut(), source);
+    commands.insert_resource(SineSink(sink));
+}
+
+fn change_pitch(
+    sink: Res<SineSink>,
+    mut assets: ResMut<Assets<AudioSink<DspSource>>>,
+    time: Res<Time>,
+) {
+    if let Some(sink) = assets.get_mut(&sink.0) {
+        let exp = time.elapsed_seconds_wrapped_f64().sin();
+        let pitch_hz = 2.0.pow(exp) * 440.0;
+
+        sink.control::<dsp_source::Iter, _>()
+            .set(FREQUENCY_ID, pitch_hz);
+    }
+}
diff --git a/examples/oddio/interactive.rs b/examples/oddio/interactive.rs
new file mode 100644
index 0000000..aaf03c4
--- /dev/null
+++ b/examples/oddio/interactive.rs
@@ -0,0 +1,44 @@
+#![allow(clippy::precedence)]
+
+use bevy::prelude::*;
+use bevy_fundsp::prelude::*;
+use bevy_oddio::{frames::Stereo, Audio, AudioPlugin, AudioSource};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(AudioPlugin)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(sine_wave, SourceType::Static { duration: 0.5 })
+        .add_dsp_source(triangle_wave, SourceType::Static { duration: 0.5 })
+        .add_system(interactive_audio)
+        .run();
+}
+
+fn sine_wave() -> impl AudioUnit32 {
+    // Note is A4
+    sine_hz(440.0) >> split::<U2>() * 0.2
+}
+
+fn triangle_wave() -> impl AudioUnit32 {
+    // Note is G4
+    triangle_hz(392.0) >> split::<U2>() * 0.2
+}
+
+fn interactive_audio(
+    input: Res<Input<KeyCode>>,
+    mut assets: ResMut<Assets<AudioSource<Stereo>>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio<Stereo, AudioSource<Stereo>>>,
+) {
+    if input.just_pressed(KeyCode::S) {
+        audio.play_dsp(assets.as_mut(), dsp_manager.get_graph(sine_wave).unwrap());
+    }
+
+    if input.just_pressed(KeyCode::T) {
+        audio.play_dsp(
+            assets.as_mut(),
+            dsp_manager.get_graph(triangle_wave).unwrap(),
+        );
+    }
+}
diff --git a/examples/oddio/noise.rs b/examples/oddio/noise.rs
new file mode 100644
index 0000000..4d5d05d
--- /dev/null
+++ b/examples/oddio/noise.rs
@@ -0,0 +1,30 @@
+#![allow(clippy::precedence)]
+
+use bevy::prelude::*;
+use bevy_fundsp::prelude::*;
+use bevy_oddio::{frames::Stereo, Audio, AudioPlugin};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugin(AudioPlugin)
+        .add_plugin(DspPlugin::default())
+        .add_dsp_source(white_noise, SourceType::Dynamic)
+        .add_startup_system_to_stage(StartupStage::PostStartup, play_noise)
+        .run();
+}
+
+fn white_noise() -> impl AudioUnit32 {
+    white() >> split::<U2>() * 0.2
+}
+
+fn play_noise(
+    mut assets: ResMut<Assets<DspSource>>,
+    dsp_manager: Res<DspManager>,
+    mut audio: ResMut<Audio<Stereo, DspSource>>,
+) {
+    let source = dsp_manager
+        .get_graph(white_noise)
+        .unwrap_or_else(|| panic!("DSP source not found!"));
+    audio.play_dsp(assets.as_mut(), source);
+}
diff --git a/justfile b/justfile
index faf65a4..bd40543 100644
--- a/justfile
+++ b/justfile
@@ -1,25 +1,15 @@
 set windows-powershell := true
 
-check:
-    cargo check
-    cargo check --no-default-features --features bevy_audio
-    cargo check --no-default-features --features kira
-    # cargo check --no-default-features --features oddio
+ci: check-fmt clippy test-all
 
-test:
+test-all:
     cargo test
-    cargo test --no-default-features --features bevy_audio
-    cargo test --no-default-features --features kira
-    # cargo test --no-default-features --features oddio
+    -cargo test --no-default-features --features bevy_audio
+    -cargo test --no-default-features --features kira
+    -cargo test --no-default-features --features oddio
 
-fmt:
+check-fmt:
     cargo fmt --all -- --check
 
 clippy:
-    cargo clippy
-
-ci:
-    just fmt
-    just clippy
-    just check
-    just test
\ No newline at end of file
+    cargo clippy
\ No newline at end of file
diff --git a/src/backend.rs b/src/backend.rs
new file mode 100644
index 0000000..312eb16
--- /dev/null
+++ b/src/backend.rs
@@ -0,0 +1,64 @@
+//! Module for the [`Backend`] trait
+//! that is implemented for each audio plugin in the Bevy ecosystem.
+
+use bevy::{prelude::App, utils::default};
+
+use crate::dsp_source::DspSource;
+
+#[cfg(feature = "bevy_audio")]
+pub mod bevy_audio;
+#[cfg(feature = "kira")]
+pub mod kira;
+#[cfg(feature = "oddio")]
+pub mod oddio;
+
+/// The default backend.
+#[allow(clippy::module_name_repetitions)]
+#[cfg(feature = "bevy_audio")]
+pub type DefaultBackend = bevy_audio::BevyAudioBackend;
+/// The default backend.
+#[allow(clippy::module_name_repetitions)]
+#[cfg(feature = "kira")]
+pub type DefaultBackend = kira::KiraBackend;
+/// The default backend.
+#[allow(clippy::module_name_repetitions)]
+#[cfg(feature = "oddio")]
+pub type DefaultBackend = oddio::OddioBackend;
+
+/// The backend trait used to convert [`DspSource`] into its concrete type.
+pub trait Backend: Send + Sync + 'static {
+    /// The static audio source.
+    /// Usually stores a collection of sound bytes.
+    type StaticAudioSource;
+
+    /// Initialization of App that is specific for the given Backend.
+    fn init_app(app: &mut App);
+    /// Convert the given [`DspSource`] to the defined static audio source.
+    fn convert_to_audio_source(dsp_source: DspSource) -> Self::StaticAudioSource;
+}
+
+/// Extension trait to add a helper method for playing DSP sources.
+pub trait DspAudioExt {
+    /// The [`Assets`](bevy::prelude::Assets)
+    /// for the concrete `Audio` type in the given backend.
+    type Assets;
+    /// The settings that are usually passed
+    /// to the concrete `Audio` type of the given backend.
+    type Settings: Default;
+    /// The audio sink that is usually returned
+    /// when playing the given DSP source.
+    type Sink;
+
+    /// Play the given [`DspSource`] with the given settings.
+    fn play_dsp_with_settings(
+        &mut self,
+        assets: &mut Self::Assets,
+        source: &DspSource,
+        settings: Self::Settings,
+    ) -> Self::Sink;
+
+    /// Play the given [`DspSource`] with the default settings.
+    fn play_dsp(&mut self, assets: &mut Self::Assets, source: &DspSource) -> Self::Sink {
+        self.play_dsp_with_settings(assets, source, default())
+    }
+}
diff --git a/src/backend/bevy_audio.rs b/src/backend/bevy_audio.rs
new file mode 100644
index 0000000..49d2fd5
--- /dev/null
+++ b/src/backend/bevy_audio.rs
@@ -0,0 +1,95 @@
+//! Implementation to integrate `bevy_fundsp` into `bevy_audio`.
+
+use crate::dsp_source::{DspSource, IterMono};
+use bevy::{
+    audio::{play_queued_audio_system, AudioSink},
+    prelude::{
+        App, Assets, Audio, AudioOutput, AudioSource, CoreStage, Decodable, Handle,
+        PlaybackSettings,
+    },
+};
+
+use super::{Backend, DspAudioExt};
+
+/// The backend for `bevy_audio`.
+#[allow(clippy::module_name_repetitions)]
+pub struct BevyAudioBackend;
+
+impl Decodable for DspSource {
+    type Decoder = IterMono;
+    type DecoderItem = f32;
+
+    fn decoder(&self) -> Self::Decoder {
+        self.clone().into_iter().into_mono()
+    }
+}
+
+impl rodio::Source for IterMono {
+    fn current_frame_len(&self) -> Option<usize> {
+        None
+    }
+
+    fn channels(&self) -> u16 {
+        1
+    }
+
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+    fn sample_rate(&self) -> u32 {
+        self.0.sample_rate as u32
+    }
+
+    fn total_duration(&self) -> Option<std::time::Duration> {
+        None
+    }
+}
+
+impl Backend for BevyAudioBackend {
+    type StaticAudioSource = AudioSource;
+
+    fn init_app(app: &mut App) {
+        app.init_resource::<Audio<DspSource>>()
+            .init_non_send_resource::<AudioOutput<DspSource>>()
+            .add_system_to_stage(CoreStage::PostUpdate, play_queued_audio_system::<DspSource>);
+    }
+
+    fn convert_to_audio_source(
+        dsp_source: crate::dsp_source::DspSource,
+    ) -> Self::StaticAudioSource {
+        let bytes = dsp_source.to_bytes().into();
+
+        AudioSource { bytes }
+    }
+}
+
+impl DspAudioExt for Audio<AudioSource> {
+    type Assets = Assets<AudioSource>;
+    type Settings = PlaybackSettings;
+    type Sink = Handle<AudioSink>;
+
+    fn play_dsp_with_settings(
+        &mut self,
+        assets: &mut Self::Assets,
+        source: &DspSource,
+        settings: Self::Settings,
+    ) -> Self::Sink {
+        let audio = BevyAudioBackend::convert_to_audio_source(source.clone());
+        let handle = assets.add(audio);
+        self.play_with_settings(handle, settings)
+    }
+}
+
+impl DspAudioExt for Audio<DspSource> {
+    type Assets = Assets<DspSource>;
+    type Settings = PlaybackSettings;
+    type Sink = Handle<AudioSink>;
+
+    fn play_dsp_with_settings(
+        &mut self,
+        assets: &mut Self::Assets,
+        source: &DspSource,
+        settings: Self::Settings,
+    ) -> Self::Sink {
+        let handle = assets.add(source.clone());
+        self.play_with_settings(handle, settings)
+    }
+}
diff --git a/src/backend/kira.rs b/src/backend/kira.rs
new file mode 100644
index 0000000..5a0e040
--- /dev/null
+++ b/src/backend/kira.rs
@@ -0,0 +1,65 @@
+//! Implementation to integrate `bevy_fundsp` into `bevy_kira_audio`.
+
+use std::io::Cursor;
+
+use bevy::prelude::App;
+use bevy_kira_audio::AudioSource;
+use kira::{
+    clock::clock_info::ClockInfoProvider,
+    sound::{
+        static_sound::{StaticSoundData, StaticSoundSettings},
+        Sound, SoundData,
+    },
+};
+
+use crate::dsp_source::{DspSource, Iter, Source};
+
+use super::Backend;
+
+impl SoundData for DspSource {
+    type Error = ();
+    type Handle = ();
+
+    fn into_sound(self) -> Result<(Box<dyn kira::sound::Sound>, Self::Handle), Self::Error> {
+        Ok((Box::new(self.into_iter()), ()))
+    }
+}
+
+impl Sound for Iter {
+    fn track(&mut self) -> kira::track::TrackId {
+        kira::track::TrackId::Main
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn process(&mut self, dt: f64, _: &ClockInfoProvider) -> kira::dsp::Frame {
+        self.advance(dt as f32);
+        let frame = self.sample();
+        kira::dsp::Frame {
+            left: frame[0],
+            right: frame[1],
+        }
+    }
+
+    fn finished(&self) -> bool {
+        false
+    }
+}
+
+/// The backend for `kira`.
+#[allow(clippy::module_name_repetitions)]
+pub struct KiraBackend;
+
+impl Backend for KiraBackend {
+    type StaticAudioSource = AudioSource;
+
+    fn init_app(_app: &mut App) {}
+
+    fn convert_to_audio_source(dsp_source: DspSource) -> Self::StaticAudioSource {
+        let bytes = dsp_source.to_bytes();
+        let cursored = Cursor::new(bytes);
+        AudioSource {
+            sound: StaticSoundData::from_cursor(cursored, StaticSoundSettings::new())
+                .unwrap_or_else(|err| panic!("Cannot read DSP source. Error: {err}")),
+        }
+    }
+}
diff --git a/src/backend/oddio.rs b/src/backend/oddio.rs
new file mode 100644
index 0000000..c280814
--- /dev/null
+++ b/src/backend/oddio.rs
@@ -0,0 +1,182 @@
+//! Implementation to integrate `bevy_fundsp` into `bevy_oddio`.
+
+use std::{cell::RefCell, rc::Rc};
+
+use bevy::prelude::{App, Assets, Handle};
+use bevy_oddio::{
+    frames::{FromFrame, Stereo},
+    oddio::{Controlled, Frame, Frames, Signal},
+    output::AudioSink,
+    Audio, AudioApp, AudioSource, ToSignal,
+};
+
+use crate::dsp_source::{DspControl, DspSource, Iter, IterMono, Source, SourceType};
+
+use super::{Backend, DspAudioExt};
+
+/// The backend for `bevy_oddio`.
+#[allow(clippy::module_name_repetitions)]
+pub struct OddioBackend;
+
+impl Backend for OddioBackend {
+    type StaticAudioSource = AudioSource<Stereo>;
+
+    fn init_app(app: &mut App) {
+        app.add_audio_source::<2, _, DspSource>();
+    }
+
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    fn convert_to_audio_source(dsp_source: DspSource) -> Self::StaticAudioSource {
+        let sample_rate = dsp_source.sample_rate;
+
+        let frames = dsp_source.into_exact_size_iter();
+
+        let frames = Frames::from_iter(sample_rate as u32, frames);
+
+        AudioSource { frames }
+    }
+}
+
+impl ToSignal for DspSource {
+    type Settings = ();
+    type Signal = Iter;
+
+    fn to_signal(&self, _settings: Self::Settings) -> Self::Signal {
+        self.clone().into_iter()
+    }
+}
+
+impl DspSource {
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+    pub(crate) fn into_exact_size_iter(
+        self,
+    ) -> ExactSizeIter<impl Iterator<Item = Stereo> + ExactSizeIterator> {
+        let audio_unit = Rc::new(RefCell::new(self.dsp_graph.generate_graph()));
+        let duration = match self.source_type {
+            SourceType::Static { duration } => duration,
+            SourceType::Dynamic => {
+                panic!("Cannot convert dynamic DSP source into exact size iterator")
+            }
+        };
+
+        let number_of_frames = (self.sample_rate * duration).round() as usize;
+
+        let collection = (0..number_of_frames)
+            .map(|_| audio_unit.clone().borrow_mut().get_stereo())
+            .map(|frame| [frame.0, frame.1])
+            .map(Stereo::from);
+
+        ExactSizeIter {
+            sample_rate: self.sample_rate,
+            collection: RefCell::new(collection.collect::<Vec<_>>().into_iter()),
+        }
+    }
+}
+
+pub(crate) struct ExactSizeIter<I>
+where
+    I: Iterator<Item = Stereo> + ExactSizeIterator,
+{
+    sample_rate: f32,
+    collection: RefCell<I>,
+}
+
+impl<I> Source for ExactSizeIter<I>
+where
+    I: Iterator<Item = Stereo> + ExactSizeIterator,
+{
+    type Frame = Stereo;
+
+    fn sample_rate(&self) -> f32 {
+        self.sample_rate
+    }
+
+    fn sample(&self) -> Self::Frame {
+        match self.collection.borrow_mut().next() {
+            Some(frame) => frame,
+            None => Stereo::ZERO,
+        }
+    }
+}
+
+impl<I> Iterator for ExactSizeIter<I>
+where
+    I: Iterator<Item = Stereo> + ExactSizeIterator,
+{
+    type Item = Stereo;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.collection.borrow_mut().next()
+    }
+}
+
+impl<I> ExactSizeIterator for ExactSizeIter<I>
+where
+    I: Iterator<Item = Stereo> + ExactSizeIterator,
+{
+    fn len(&self) -> usize {
+        self.collection.borrow().len()
+    }
+}
+
+impl Signal for Iter {
+    type Frame = Stereo;
+
+    fn sample(&self, interval: f32, out: &mut [Self::Frame]) {
+        self.advance(interval);
+        for out_frame in out {
+            let frame = Source::sample(self);
+            let stereo: Stereo = FromFrame::from_frame(frame);
+            *out_frame = stereo;
+        }
+    }
+}
+
+impl DspAudioExt for Audio<Stereo, AudioSource<Stereo>> {
+    type Assets = Assets<AudioSource<Stereo>>;
+    type Settings = <AudioSource<Stereo> as ToSignal>::Settings;
+    type Sink = Handle<AudioSink<AudioSource<Stereo>>>;
+
+    fn play_dsp_with_settings(
+        &mut self,
+        assets: &mut Self::Assets,
+        source: &DspSource,
+        settings: Self::Settings,
+    ) -> Self::Sink {
+        let audio_source = OddioBackend::convert_to_audio_source(source.clone());
+        let source_handle = assets.add(audio_source);
+        self.play(source_handle, settings)
+    }
+}
+
+impl DspAudioExt for Audio<Stereo, DspSource> {
+    type Assets = Assets<DspSource>;
+    type Settings = <DspSource as ToSignal>::Settings;
+    type Sink = Handle<AudioSink<DspSource>>;
+
+    fn play_dsp_with_settings(
+        &mut self,
+        assets: &mut Self::Assets,
+        source: &DspSource,
+        settings: Self::Settings,
+    ) -> Self::Sink {
+        let source_handle = assets.add(source.clone());
+        self.play(source_handle, settings)
+    }
+}
+
+unsafe impl<'a> Controlled<'a> for Iter {
+    type Control = DspControl;
+
+    unsafe fn make_control(signal: &'a Self) -> Self::Control {
+        DspControl::new(signal.sender.clone())
+    }
+}
+
+unsafe impl<'a> Controlled<'a> for IterMono {
+    type Control = DspControl;
+
+    unsafe fn make_control(signal: &'a Self) -> Self::Control {
+        Iter::make_control(&signal.0)
+    }
+}
diff --git a/src/dsp_graph.rs b/src/dsp_graph.rs
new file mode 100644
index 0000000..f547ca7
--- /dev/null
+++ b/src/dsp_graph.rs
@@ -0,0 +1,43 @@
+//! Module for the [`DspGraph`] trait.
+
+use fundsp::prelude::AudioUnit32;
+use uuid::Uuid;
+
+/// Trait for generating DSP sources.
+///
+/// This is the public interface for registering custom DSP graphs.
+///
+/// Currently, this is only implemented for functions
+/// that implement `Fn() -> impl AudioUnit32`.
+///
+/// If parameterless functions isn't enough for your usecase,
+/// you can implement your own custom type.
+pub trait DspGraph: Send + Sync + 'static {
+    /// The ID of the given graph.
+    ///
+    /// Different graphs must return different IDs,
+    /// even if they return the same type.
+    ///
+    /// This is used internally in [`DspManager`].
+    ///
+    /// [`DspManager`]: crate::dsp_manager::DspManager
+    fn id(&self) -> Uuid;
+
+    /// Generate a DSP graph.
+    fn generate_graph(&self) -> Box<dyn AudioUnit32>;
+}
+
+impl<F, Au> DspGraph for F
+where
+    F: Send + Sync + 'static + Fn() -> Au,
+    Au: AudioUnit32 + 'static,
+{
+    fn id(&self) -> Uuid {
+        // TODO: This should be based on its `TypeId`
+        Uuid::new_v5(&Uuid::NAMESPACE_OID, std::any::type_name::<F>().as_bytes())
+    }
+
+    fn generate_graph(&self) -> Box<dyn AudioUnit32> {
+        Box::new(self())
+    }
+}
diff --git a/src/dsp_manager.rs b/src/dsp_manager.rs
new file mode 100644
index 0000000..ad262ff
--- /dev/null
+++ b/src/dsp_manager.rs
@@ -0,0 +1,51 @@
+//! Module for [`DspManager`].
+
+use bevy::{
+    prelude::{default, Resource},
+    utils::HashMap,
+};
+use uuid::Uuid;
+
+use crate::{
+    dsp_graph::DspGraph,
+    dsp_source::{DspSource, SourceType},
+    DEFAULT_SAMPLE_RATE,
+};
+
+/// Manages the registered DSP sources.
+///
+/// This is a public facing interface
+/// for the user to access the stored DSP sources.
+#[derive(Resource)]
+pub struct DspManager {
+    collection: HashMap<Uuid, DspSource>,
+    sample_rate: f32,
+}
+
+impl Default for DspManager {
+    fn default() -> Self {
+        Self::new(*DEFAULT_SAMPLE_RATE)
+    }
+}
+
+impl DspManager {
+    pub(crate) fn new(sample_rate: f32) -> Self {
+        Self {
+            sample_rate,
+            collection: default(),
+        }
+    }
+
+    pub(crate) fn add_graph<D: DspGraph>(&mut self, dsp_graph: D, source_type: SourceType) {
+        self.collection.insert(
+            dsp_graph.id(),
+            DspSource::new(dsp_graph, self.sample_rate, source_type),
+        );
+    }
+
+    /// Get the DSP source given a DSP graph.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn get_graph<D: DspGraph>(&self, dsp_graph: D) -> Option<&DspSource> {
+        self.collection.get(&dsp_graph.id())
+    }
+}
diff --git a/src/dsp_source.rs b/src/dsp_source.rs
new file mode 100644
index 0000000..c8cc1f3
--- /dev/null
+++ b/src/dsp_source.rs
@@ -0,0 +1,314 @@
+//! Module for [`DspSource`],
+//! a type that is analogous to `AudioSource` in `bevy_audio`.
+
+use crate::dsp_graph::DspGraph;
+use bevy::reflect::TypeUuid;
+use fundsp::{hacker32::AudioUnit32, prelude::Tag, wave::Wave32};
+use parking_lot::Mutex;
+use ringbuf::{Consumer, HeapRb, Producer};
+use std::{cell::RefCell, sync::Arc};
+
+type SetTag = (Tag, f64);
+
+/// A DSP source similar to `AudioSource` in `bevy_audio`.
+///
+/// These can be played directly when the [`SourceType`] is dynamic,
+/// otherwise, the DSP source must be played with a given duration.
+#[derive(TypeUuid, Clone)]
+#[uuid = "107a9069-d37d-46a8-92f2-23ec23b73bf6"]
+pub struct DspSource {
+    pub(crate) dsp_graph: Arc<dyn DspGraph>,
+    pub(crate) sample_rate: f32,
+    pub(crate) source_type: SourceType,
+}
+
+/// The type of the [`DspSource`].
+#[derive(Debug, Clone, Copy)]
+pub enum SourceType {
+    /// Indicates that the DSP source is static.
+    /// This means that the playing sound is simply a collection of bytes.
+    /// Therefore, the audio is of definite length,
+    /// and the sound last for the given duration.
+    ///
+    /// See [`Wave32`](fundsp::wave::Wave32) on how this is converted.
+    Static {
+        /// The duration of the source in seconds.
+        duration: f32,
+    },
+    /// Indicates that the DSP source is dynamic.
+    /// This means that the playing sound last forever.
+    /// Internally, each frame is computed manually,
+    /// and not referenced from an internal collection of bytes.
+    ///
+    /// See [`Iter`].
+    Dynamic,
+}
+
+impl DspSource {
+    pub(crate) fn new<D: DspGraph>(
+        dsp_graph: D,
+        sample_rate: f32,
+        source_type: SourceType,
+    ) -> Self {
+        Self {
+            dsp_graph: Arc::new(dsp_graph),
+            sample_rate,
+            source_type,
+        }
+    }
+
+    /// Convert the DSP source to its corresponding bytes.
+    ///
+    /// The source type must be static,
+    /// otherwise it will panic,
+    /// as it does not know how long it is.
+    ///
+    /// Internally, this uses [`fundsp::wave::Wave32`].
+    #[cfg_attr(feature = "oddio", allow(dead_code))]
+    pub(crate) fn to_bytes(&self) -> Vec<u8> {
+        let duration = match self.source_type {
+            SourceType::Static { duration } => duration,
+            SourceType::Dynamic => panic!("Only static DSP sources can be converted into bytes."),
+        };
+
+        let mut node = self.dsp_graph.generate_graph();
+
+        let wave = Wave32::render(
+            f64::from(self.sample_rate),
+            f64::from(duration),
+            node.as_mut(),
+        );
+
+        let mut buffer = Vec::new();
+
+        wave.write_wav16(&mut buffer)
+            .unwrap_or_else(|err| panic!("Cannot write wave to buffer. Error: {err:?}"));
+
+        buffer
+    }
+}
+
+impl IntoIterator for DspSource {
+    type Item = [f32; 2];
+    type IntoIter = Iter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let (sender, receiver) = HeapRb::new(64).split();
+
+        Iter {
+            sample_rate: self.sample_rate,
+            audio_unit: RefCell::new(self.dsp_graph.generate_graph()),
+            sender: Arc::new(Mutex::new(sender)),
+            receiver: RefCell::new(receiver),
+        }
+    }
+}
+
+/// An iterator of the DSP source
+/// whose item is a stereo sample.
+///
+/// This is infinite, and would never return `None`.
+pub struct Iter {
+    pub(crate) sample_rate: f32,
+    pub(crate) audio_unit: RefCell<Box<dyn AudioUnit32>>,
+    pub(crate) sender: Arc<Mutex<Producer<SetTag, Arc<HeapRb<SetTag>>>>>,
+    pub(crate) receiver: RefCell<Consumer<SetTag, Arc<HeapRb<SetTag>>>>,
+}
+
+pub(crate) trait Source {
+    type Frame;
+
+    fn sample_rate(&self) -> f32;
+    fn sample(&self) -> Self::Frame;
+
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+    fn advance(&self, dt: f32) {
+        for _ in 0..(self.sample_rate() * dt) as usize {
+            self.sample();
+        }
+    }
+}
+
+impl Iter {
+    /// Convert the iterator into a different iterator
+    /// that returns mono samples.
+    pub fn into_mono(self) -> IterMono {
+        IterMono(self)
+    }
+}
+
+impl Source for Iter {
+    type Frame = [f32; 2];
+
+    fn sample_rate(&self) -> f32 {
+        self.sample_rate
+    }
+
+    fn sample(&self) -> Self::Frame {
+        while let Some((parameter, value)) = self.receiver.borrow_mut().pop() {
+            self.audio_unit.borrow_mut().set(parameter, value);
+        }
+        let frame = self.audio_unit.borrow_mut().get_stereo();
+        [frame.0, frame.1]
+    }
+}
+
+impl Iterator for Iter {
+    type Item = [f32; 2];
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.sample())
+    }
+}
+
+/// An iterator that returns mono samples.
+/// This is similar to [`Iter`].
+///
+/// Internally, only `bevy_audio` uses this.
+pub struct IterMono(pub(crate) Iter);
+
+impl Source for IterMono {
+    type Frame = f32;
+
+    fn sample_rate(&self) -> f32 {
+        self.0.sample_rate
+    }
+
+    fn sample(&self) -> f32 {
+        while let Some((parameter, value)) = self.0.receiver.borrow_mut().pop() {
+            self.0.audio_unit.borrow_mut().set(parameter, value);
+        }
+        self.0.audio_unit.borrow_mut().get_mono()
+    }
+}
+
+impl Iterator for IterMono {
+    type Item = f32;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        Some(self.sample())
+    }
+}
+
+/// Handle for controlling playing DSP sources.
+///
+/// Generally, this is used to get or set the tags of a FunDSP graph.
+pub struct DspControl {
+    sender: Arc<Mutex<Producer<SetTag, Arc<HeapRb<SetTag>>>>>,
+}
+
+impl DspControl {
+    pub(crate) fn new(sender: Arc<Mutex<Producer<SetTag, Arc<HeapRb<SetTag>>>>>) -> Self {
+        Self { sender }
+    }
+
+    /// Set the tag to the given value.
+    ///
+    /// See more documentation in [AudioUnit32::set].
+    ///
+    /// [AudioUnit32::set]: fundsp::audiounit::AudioUnit32::set
+    pub fn set(&self, tag: Tag, value: f64) {
+        while self.sender.lock().push((tag, value)).is_err() {}
+    }
+}
+
+pub(crate) trait Controllable {
+    type Control;
+
+    fn control(&self) -> Self::Control;
+}
+
+impl Controllable for Iter {
+    type Control = DspControl;
+
+    fn control(&self) -> Self::Control {
+        DspControl::new(self.sender.clone())
+    }
+}
+
+impl Controllable for IterMono {
+    type Control = DspControl;
+
+    fn control(&self) -> Self::Control {
+        self.0.control()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::wildcard_imports)]
+
+    use crate::{dsp_source::Controllable, DEFAULT_SAMPLE_RATE};
+
+    use super::{DspSource, SourceType};
+    use fundsp::hacker32::*;
+
+    #[test]
+    fn constant_signal() {
+        let source = DspSource::new(
+            || constant(440.0),
+            *DEFAULT_SAMPLE_RATE,
+            SourceType::Dynamic,
+        );
+
+        let mut iter = source.into_iter();
+
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+
+        let mut iter = iter.into_mono();
+
+        assert_eq!(iter.next(), Some(440.0));
+        assert_eq!(iter.next(), Some(440.0));
+        assert_eq!(iter.next(), Some(440.0));
+    }
+
+    #[test]
+    fn sine_wave_signal() {
+        let sine_wave = || constant(440.0) >> sine();
+
+        let source = DspSource::new(sine_wave, *DEFAULT_SAMPLE_RATE, SourceType::Dynamic);
+
+        let iter = source.into_iter().into_mono();
+        let mut signal = sine_wave();
+
+        for sample in iter.take(1_000) {
+            let signal_sample = signal.get_mono();
+            assert!((signal_sample - sample).abs() < f32::EPSILON);
+        }
+    }
+
+    #[test]
+    fn constant_controllable() {
+        const FREQ_ID: Tag = 0;
+
+        let sine_wave = || tag(FREQ_ID, 440.0);
+
+        let source = DspSource::new(sine_wave, *DEFAULT_SAMPLE_RATE, SourceType::Dynamic);
+
+        let mut iter = source.into_iter();
+
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+        assert_eq!(iter.next(), Some([440.0, 440.0]));
+
+        iter.control().set(FREQ_ID, 880.0);
+
+        assert_eq!(iter.next(), Some([880.0, 880.0]));
+        assert_eq!(iter.next(), Some([880.0, 880.0]));
+        assert_eq!(iter.next(), Some([880.0, 880.0]));
+
+        let mut iter = iter.into_mono();
+
+        assert_eq!(iter.next(), Some(880.0));
+        assert_eq!(iter.next(), Some(880.0));
+        assert_eq!(iter.next(), Some(880.0));
+
+        iter.control().set(FREQ_ID, 440.0);
+
+        assert_eq!(iter.next(), Some(440.0));
+        assert_eq!(iter.next(), Some(440.0));
+        assert_eq!(iter.next(), Some(440.0));
+    }
+}
diff --git a/src/kira_impl.rs b/src/kira_impl.rs
deleted file mode 100644
index 9100a98..0000000
--- a/src/kira_impl.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use std::{any::TypeId, io::Cursor};
-
-use bevy_kira_audio::AudioSource;
-use kira::sound::{
-    static_sound::{StaticSoundData, StaticSoundSettings},
-    FromFileError,
-};
-
-use crate::{DspGraph, DspManager, DspSource, FnDspGraph, Settings};
-
-impl DspSource {
-    /// Returns a [`StaticSoundData`].
-    ///
-    /// This is useful if you are using [`bevy_kira_audio`].
-    ///
-    /// [`StaticSoundData`]: kira::sound::static_sound::StaticSoundData
-    ///
-    /// # Errors
-    ///
-    /// This will return an error if the DSP graph cannot be parsed into a `StaticSoundData`.
-    pub fn into_kira_sound_data(
-        self,
-        settings: StaticSoundSettings,
-    ) -> Result<StaticSoundData, FromFileError> {
-        let raw_bytes = self.generate_raw_bytes();
-
-        StaticSoundData::from_cursor(Cursor::new(raw_bytes), settings)
-    }
-
-    /// Convert this to an audio source.
-    ///
-    /// # Panics
-    ///
-    /// This can panic when `kira` is enabled and the source cannot be converted to a `StaticSoundData`
-    #[must_use]
-    pub fn into_audio_source(self, settings: Settings) -> AudioSource {
-        let sound = self.into_kira_sound_data(settings).unwrap_or_else(|err| {
-            panic!("Cannot convert DSP source to sound data. Error: {err:?}")
-        });
-
-        AudioSource { sound }
-    }
-}
-
-impl DspGraph {
-    /// Create a new graph from the graph function, its length in seconds, and `kira`'s [`StaticSoundSettings`].
-    #[must_use]
-    pub fn with_settings(func: Box<dyn FnDspGraph>, length: f64, settings: Settings) -> Self {
-        Self {
-            func,
-            length,
-            settings,
-        }
-    }
-}
-
-impl DspManager {
-    /// Add a new graph into the manager with the given settings.
-    pub fn add_graph_with_settings<F: FnDspGraph>(
-        &mut self,
-        f: F,
-        length: f64,
-        settings: Settings,
-    ) -> &mut Self {
-        self.graphs.insert(
-            TypeId::of::<F>(),
-            DspGraph::with_settings(Box::new(f), length, settings),
-        );
-        self
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index 417ccc3..028508d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,368 +1,166 @@
-#![warn(clippy::pedantic)]
 #![warn(missing_docs)]
+#![warn(clippy::pedantic)]
+#![allow(clippy::doc_markdown)]
 
-//! DSP plugin for the game engine Bevy.
-//!
-//! When using types from `fundsp`, always use the `f32` version (`AudioUnit32`, etc).
+//! This library integrates [FunDSP] into [Bevy].
 //!
-//! **Always lower your volume when testing sound.**
+//! When using this library, **remember to lower your volume first**!
 //!
-//! Also, when writing DSP graphs while using clippy, you may encounter the following warning:
+//! Also, you may encounter the following error when using this library:
 //!
-//! ```ignore
+//! ```text no_run
 //! warning: operator precedence can trip the unwary
-//! --> examples/kira/noise.rs:14:5
-//! |
-//! |     white() * 0.2 >> split::<U2>()
-//! |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `(white() * 0.2) >> split::<U2>()`
-//! |
-//! = note: `#[warn(clippy::precedence)]` on by default
-//! = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#precedence
-//! ```
+//!   --> examples/bevy_audio/noise.rs:22:5
+//!    |
+//! 22 |     white() >> split::<U2>() * 0.2
+//!    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `white() >> (split::<U2>() * 0.2)`
+//!    |
+//!    = note: `#[warn(clippy::precedence)]` on by default
+//!    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#precedence
 //!
-//! It is recommended to add `#![allow(clippy::precedence)]` at the top of your crate to stop seeing this error,
-//! or applying `#[allow(clippy::precendence)]` at every DSP graph function.
-//! See the [`FunDSP` README] for more information.
+//! warning: `bevy_fundsp` (example "noise") generated 1 warning
+//! ```
 //!
-//! [`FunDSP` README]: https://github.com/SamiPerttu/fundsp
-
-#[cfg(all(feature = "bevy_audio", feature = "kira"))]
-compile_error!("feature \"bevy_audio\" and feature \"kira\" cannot be enabled at the same time");
-#[cfg(all(feature = "kira", feature = "oddio"))]
-compile_error!("feature \"kira\" and feature \"oddio\" cannot be enabled at the same time");
-#[cfg(all(feature = "bevy_audio", feature = "oddio"))]
-compile_error!("feature \"bevy_audio\" and feature \"oddio\" cannot be enabled at the same time");
-
-use std::{
-    any::{type_name, Any, TypeId},
-    cell::RefCell,
-};
-
-#[cfg(feature = "bevy_audio")]
-use bevy::audio::AudioSource;
-#[cfg(feature = "kira")]
-use bevy_kira_audio::AudioSource;
-#[cfg(feature = "oddio")]
-use bevy_oddio::AudioSource;
-
-use bevy::{
-    asset::{Assets, Handle},
-    prelude::{App, Commands, Plugin, Res, ResMut, StageLabel, StartupStage, SystemStage},
-    utils::HashMap,
-};
-pub use fundsp::hacker32;
-use fundsp::hacker32::{AudioUnit32, Wave32};
-
-#[cfg(feature = "kira")]
-mod kira_impl;
-#[cfg(feature = "oddio")]
-mod oddio_impl;
-#[cfg(feature = "bevy_audio")]
-mod rodio_impl;
-
-/// A source of a DSP graph.
-pub struct DspSource {
-    graph: Box<dyn AudioUnit32>,
-    sample_rate: f64,
-    length: f64,
-}
-
-impl DspSource {
-    /// Creates a new DSP data source from the given graph.
-    pub fn new<X: AudioUnit32 + 'static>(graph: X, sample_rate: f64, length: f64) -> Self {
-        Self {
-            graph: Box::new(graph),
-            sample_rate,
-            length,
-        }
-    }
-
-    /// Creates a new DSP data source from a boxed audio unit.
-    #[must_use]
-    pub fn from_boxed(graph: Box<dyn AudioUnit32>, sample_rate: f64, length: f64) -> Self {
-        Self {
-            graph,
-            sample_rate,
-            length,
-        }
-    }
-
-    /// Generate the raw bytes of a DSP graph given the sample rate and its length.
+//! This isn't necessary when writing your DSP graphs.
+//! It is more intuitive to remove the parentheses when writing these types of expressions,
+//! as FunDSP is essentially a domain specific language.
+//! See the [FunDSP] README for more information.
+//!  
+//! [FunDSP]: https://github.com/SamiPerttu/fundsp
+//! [Bevy]: https://bevyengine.org/
+
+use backend::{Backend, DefaultBackend};
+use bevy::prelude::{AddAsset, App, Plugin};
+use dsp_graph::DspGraph;
+use dsp_manager::DspManager;
+use dsp_source::{DspSource, SourceType};
+use once_cell::sync::Lazy;
+
+pub mod backend;
+pub mod dsp_graph;
+pub mod dsp_manager;
+pub mod dsp_source;
+
+/// Add support for using [FunDSP graphs] in Bevy code.
+///
+/// ```no_run
+/// # use bevy::prelude::*;
+/// # use bevy_fundsp::prelude::*;
+/// App::new()
+///     .add_plugins(DefaultPlugins)
+///     .add_plugin(DspPlugin::default())
+///     .run()
+/// ```
+pub struct DspPlugin {
+    sample_rate: f32,
+}
+
+impl DspPlugin {
+    /// Construct the plugin given the sample rate.
     ///
-    /// # Panics
+    /// It is recommended to use the [`Default`]
+    /// implementation to avoid problems with audio output.
     ///
-    /// This panics when it cannot write the DSP graph to a wave buffer.
-    #[must_use]
-    pub fn generate_raw_bytes(mut self) -> Vec<u8> {
-        let wave = Wave32::render(self.sample_rate, self.length, self.graph.as_mut());
-
-        let mut buffer = Vec::new();
-
-        wave.write_wav16(&mut buffer)
-            .unwrap_or_else(|err| panic!("Cannot write wave to buffer. Error: {err:?}"));
-
-        buffer
-    }
-}
-
-/// A DSP graph used for streaming sound data potientally forever.
-pub struct StreamingDspSource {
-    // Mutex/RwLock blocks, so we use RefCell
-    graph: RefCell<Box<dyn AudioUnit32>>,
-    #[allow(dead_code)] // This only warn when `bevy_audio` is selected.
-    sample_rate: f64,
-}
-
-impl StreamingDspSource {
-    /// Generate a new [`StreamingDspSource`]
-    #[must_use]
-    pub fn new(graph: Box<dyn AudioUnit32>, sample_rate: f64) -> Self {
-        Self {
-            graph: RefCell::new(graph),
-            sample_rate,
-        }
-    }
-
-    /// Generate the next frame of the graph.
-    pub fn next_frame(&self) -> (f32, f32) {
-        self.graph.borrow_mut().get_stereo()
-    }
-}
-
-impl Iterator for StreamingDspSource {
-    type Item = (f32, f32);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        Some(self.next_frame())
-    }
-}
-
-// This turns [`DspSource`] into a [`StreamingDspSource`] that streams forever.
-impl IntoIterator for DspSource {
-    type Item = (f32, f32);
-    type IntoIter = StreamingDspSource;
-
-    fn into_iter(self) -> Self::IntoIter {
-        StreamingDspSource::new(self.graph, self.sample_rate)
+    /// Internally, the default plugin gets the sample rate
+    /// of the device using [`cpal`].
+    ///
+    /// ```no_run
+    /// # use bevy::prelude::*;
+    /// # use bevy_fundsp::prelude::*;
+    /// App::new()
+    ///     .add_plugins(DefaultPlugins)
+    ///     .add_plugin(DspPlugin::new(44100.0))
+    ///     .run()
+    /// ```
+    #[allow(clippy::must_use_candidate)]
+    pub fn new(sample_rate: f32) -> Self {
+        Self { sample_rate }
     }
 }
 
-/// A trait that is implemented for all functions
-/// that accepts no input and returns an audio graph.
-pub trait FnDspGraph: Send + Sync + 'static {
-    /// Generate a boxed graph.
-    fn generate_graph(&self) -> Box<dyn AudioUnit32>;
-}
-
-impl<X: AudioUnit32 + 'static, F> FnDspGraph for F
-where
-    F: Fn() -> X + Send + Sync + 'static,
-{
-    fn generate_graph(&self) -> Box<dyn AudioUnit32> {
-        Box::new(self())
+impl Default for DspPlugin {
+    fn default() -> Self {
+        Self::new(*DEFAULT_SAMPLE_RATE)
     }
 }
 
-#[cfg(any(feature = "bevy_audio", feature = "oddio"))]
-type Settings = ();
-#[cfg(feature = "kira")]
-type Settings = kira::sound::static_sound::StaticSoundSettings;
-
-/// A DSP graph struct used in the manager.
-pub struct DspGraph {
-    func: Box<dyn FnDspGraph>,
-    length: f64,
-    #[allow(dead_code)]
-    settings: Settings,
-}
+impl Plugin for DspPlugin {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(DspManager::new(self.sample_rate))
+            .add_asset::<DspSource>();
 
-impl DspGraph {
-    /// Create a new graph from the graph function and its length in seconds.
-    #[must_use]
-    pub fn new(func: Box<dyn FnDspGraph>, length: f64) -> Self {
-        Self {
-            func,
-            length,
-            settings: Settings::default(),
-        }
+        DefaultBackend::init_app(app);
     }
 }
 
-/// Manages all DSP graphs.
-/// This is automatically added as a resource.
-pub struct DspManager {
-    graphs: HashMap<TypeId, DspGraph>,
-    sample_rate: f64,
-}
-
-impl DspManager {
-    /// Add a new graph into the manager.
+/// Trait extension for the [`App`] struct.
+pub trait DspAppExt {
+    /// Register a DSP source with the given [`SourceType`].
     ///
-    /// # Example
+    /// The type to be registered must implement [`DspGraph`].
     ///
     /// ```no_run
-    /// use bevy_fundsp::prelude::*;
-    /// use bevy::prelude::*;
+    /// # use bevy::prelude::*;
+    /// # use bevy_fundsp::prelude::*;
+    /// App::new()
+    ///     .add_plugins(DefaultPlugins)
+    ///     .add_plugin(DspPlugin::default())
+    ///     .add_dsp_source(a_simple_440hz_sine_wave, SourceType::Dynamic)
+    ///     .run();
     ///
-    /// fn main() {
-    ///     App::new()
-    ///         .add_plugins(DefaultPlugins)
-    ///         .add_plugin(DspPlugin)
-    ///         .add_startup_system(init_graph)
-    ///         .run();
-    /// }
-    ///
-    /// fn white_noise() -> impl AudioUnit32 {
-    ///     noise() * 0.2 >> split::<U2>()
-    /// }
-    ///
-    /// fn init_graph(mut dsp_manager: NonSendMut<DspManager>) {
-    ///     dsp_manager.add_graph(white_noise, 5.0);
+    /// fn a_simple_440hz_sine_wave() -> impl AudioUnit32 {
+    ///     sine_hz(440.0)
     /// }
     /// ```
-    pub fn add_graph<F: FnDspGraph>(&mut self, f: F, length: f64) -> &mut Self {
-        self.graphs
-            .insert(TypeId::of::<F>(), DspGraph::new(Box::new(f), length));
-        self
-    }
-
-    /// Remove a graph from the manager.
-    pub fn remove_graph<F: FnDspGraph>(&mut self, f: &F) -> &mut Self {
-        self.graphs.remove(&Any::type_id(f));
-        self
-    }
-
-    /// Get a graph from the manager.
-    pub fn get_graph<F: FnDspGraph>(&self, f: &F) -> Option<DspSource> {
-        self.graphs.get(&Any::type_id(f)).map(|graph| {
-            DspSource::from_boxed(graph.func.generate_graph(), self.sample_rate, graph.length)
-        })
-    }
-
-    /// Generate asset handles for all DSP graphs.
-    ///
-    /// # Panics
-    ///
-    /// This panics if the [`DspSource`] cannot be converted to a `kira` sound data.
-    pub fn add_assets(&self, assets: &mut Assets<AudioSource>) -> DspAssets {
-        let handles = self
-            .graphs
-            .iter()
-            .map(|(type_id, graph)| {
-                let audio_graph = graph.func.generate_graph();
-                let dsp_source = DspSource::from_boxed(audio_graph, self.sample_rate, graph.length);
-
-                #[cfg(feature = "bevy_audio")]
-                let audio_source = dsp_source.into_audio_source();
-                #[cfg(feature = "kira")]
-                let audio_source = dsp_source.into_audio_source(graph.settings);
-                #[cfg(feature = "oddio")]
-                let audio_source = dsp_source.into_audio_source(self.sample_rate);
-
-                let handle = assets.add(audio_source);
-                (*type_id, handle)
-            })
-            .collect();
-        DspAssets::new(handles)
-    }
-}
-
-impl Default for DspManager {
-    fn default() -> Self {
-        Self {
-            graphs: HashMap::default(),
-            sample_rate: 44100.0,
-        }
-    }
+    fn add_dsp_source<D: DspGraph>(&mut self, dsp_graph: D, source_type: SourceType) -> &mut Self;
 }
 
-/// Hashmap for handles of audio sources for DSP graphs.
-///
-/// This is only available when the `kira` feature is enabled.
-///
-/// The `DspAssets` resource is initialized before the post-startup stage.
-pub struct DspAssets {
-    handles: HashMap<TypeId, Handle<AudioSource>>,
-}
+impl DspAppExt for App {
+    fn add_dsp_source<D: DspGraph>(&mut self, dsp_graph: D, source_type: SourceType) -> &mut Self {
+        let mut dsp_manager = self.world.resource_mut::<DspManager>();
 
-impl DspAssets {
-    fn new(handles: HashMap<TypeId, Handle<AudioSource>>) -> Self {
-        Self { handles }
-    }
+        dsp_manager.add_graph(dsp_graph, source_type);
 
-    /// Get a handle to the audio source from the assets.
-    pub fn get_graph<X, F>(&self, f: F) -> Option<&Handle<AudioSource>>
-    where
-        X: AudioUnit32 + 'static,
-        F: Fn() -> X + 'static,
-    {
-        self.handles.get(&Any::type_id(&f))
-    }
-
-    /// Get a handle to the audio source from the assets.
-    ///
-    /// # Panics
-    ///
-    /// This panics when the given function is not found in the assets map.
-    pub fn graph<F: FnDspGraph>(&self, f: &F) -> Handle<AudioSource> {
-        self.handles
-            .get(&Any::type_id(f))
-            .unwrap_or_else(|| {
-                panic!(
-                    "DSP asset does not exist with the key {:?}.",
-                    type_name::<F>()
-                )
-            })
-            .clone()
+        self
     }
 }
 
-/// A Bevy plugin for adding DSP graphs.
-///
-/// Add this plugin to your Bevy app
-/// to get access to the [`DspManager`] non-send resource.
-///
-/// Be careful when playing DSP graphs.
-/// ⚠ **Lower your volume when testing sound**. ⚠
-pub struct DspPlugin;
+static DEFAULT_SAMPLE_RATE: Lazy<f32> = Lazy::new(default_sample_rate);
 
-/// Stage where [`DspManager`] automatically adds assets.
-struct AddDspAssetsStage;
+#[cfg(not(test))]
+fn default_sample_rate() -> f32 {
+    use cpal::traits::{DeviceTrait, HostTrait};
 
-impl StageLabel for AddDspAssetsStage {
-    fn as_str(&self) -> &'static str {
-        "add_dsp_assets_stage"
-    }
-}
+    let host = cpal::default_host();
+    let device = host
+        .default_output_device()
+        .unwrap_or_else(|| panic!("No output device available."));
+    let default_config = device
+        .default_output_config()
+        .unwrap_or_else(|err| panic!("Cannot find default stream config. Error: {err}"));
 
-impl Plugin for DspPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_resource::<DspManager>();
-
-        app.add_startup_stage_before(
-            StartupStage::PostStartup,
-            AddDspAssetsStage,
-            SystemStage::parallel(),
-        );
-
-        app.add_startup_system_to_stage(AddDspAssetsStage, generate_assets);
+    #[allow(clippy::cast_precision_loss)]
+    {
+        default_config.sample_rate().0 as f32
     }
 }
 
-/// System to generate assets from [`DspManager`]
-#[allow(clippy::needless_pass_by_value)]
-fn generate_assets(
-    mut commands: Commands,
-    dsp_manager: Res<DspManager>,
-    mut assets: ResMut<Assets<AudioSource>>,
-) {
-    let assets = dsp_manager.add_assets(&mut assets);
-    commands.insert_resource(assets);
+#[cfg(test)]
+fn default_sample_rate() -> f32 {
+    bevy::log::warn!("This is in test mode!");
+    44100.0
 }
 
-/// Import the most commonly used items by doing `use bevy_fundsp::prelude::*;`.
+/// Prelude for all `bevy_fundsp` types.
+///
+/// This also includes the `fundsp::hacker32` prelude.
 pub mod prelude {
-    pub use super::*;
+    pub use crate::backend::{Backend, DefaultBackend, DspAudioExt};
+    pub use crate::dsp_graph::DspGraph;
+    pub use crate::dsp_manager::DspManager;
+    pub use crate::dsp_source::{DspSource, Iter, IterMono, SourceType};
+    pub use crate::DspAppExt;
+    pub use crate::DspPlugin;
     pub use fundsp::hacker32::*;
 }
 
diff --git a/src/oddio_impl.rs b/src/oddio_impl.rs
deleted file mode 100644
index 183d4a7..0000000
--- a/src/oddio_impl.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use bevy_oddio::{oddio::Frames, AudioSource};
-
-use crate::{DspSource, StreamingDspSource};
-
-impl DspSource {
-    /// Convert this to an audio source.
-    #[must_use]
-    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
-    pub fn into_audio_source(self, sample_rate: f64) -> AudioSource {
-        let mut bytes: Vec<f32> = self
-            .generate_raw_bytes()
-            .into_iter()
-            .map(f32::from)
-            .collect();
-
-        let bytes = bevy_oddio::oddio::frame_stereo(&mut bytes);
-
-        let frames = Frames::from_slice(sample_rate as u32, bytes);
-
-        AudioSource { frames }
-    }
-}
-
-impl bevy_oddio::oddio::Signal for StreamingDspSource {
-    type Frame = bevy_oddio::Stereo;
-
-    #[allow(
-        clippy::cast_sign_loss,
-        clippy::cast_possible_truncation,
-        clippy::cast_lossless
-    )]
-    fn sample(&self, interval: f32, out: &mut [Self::Frame]) {
-        for _ in 0..(interval as f64 * self.sample_rate) as usize {
-            self.next_frame();
-        }
-
-        for o in out {
-            let (left, right) = self.next_frame();
-            o[0] = left;
-            o[1] = right;
-        }
-    }
-}
diff --git a/src/rodio_impl.rs b/src/rodio_impl.rs
deleted file mode 100644
index e03eabf..0000000
--- a/src/rodio_impl.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use bevy::audio::AudioSource;
-
-use crate::DspSource;
-
-impl DspSource {
-    /// Convert this to an audio source.
-    #[must_use]
-    pub fn into_audio_source(self) -> AudioSource {
-        let bytes: std::sync::Arc<[u8]> = self.generate_raw_bytes().into();
-
-        AudioSource { bytes }
-    }
-}