diff --git a/Cargo.toml b/Cargo.toml
index ae575af..4437181 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "midix"
-version = "4.0.0-alpha"
+version = "4.0.0-alpha.1"
 authors = ["dsgallups <dsgallups@protonmail.com>"]
 edition = "2024"
 description = "MIDI structures designed for humans"
@@ -15,51 +15,22 @@ exclude = ["assets/*"]
 
 [features]
 default = ["std"]
-all = ["std", "bevy_resources", "web"]
-std = ["thiserror/std", "num_enum/std", "crossbeam-channel/std"]
+std = ["thiserror/std"]
 web = ["bevy_platform/web"]
-bevy_resources = [
-    "bevy",
-    "dep:midir",
-    "dep:tinyaudio",
-    "dep:itertools",
-    "dep:rustysynth",
-    "dep:crossbeam-channel",
-]
-bevy = ["bevy_resources", "bevy/bevy_log", "std", "bevy/bevy_asset"]
-debug = ["bevy_resources"]
-example = [
-    "bevy_resources",
-    "std",
-    "bevy/bevy_color",
-    "bevy/bevy_core_pipeline",
-    "bevy/bevy_ui",
-    "bevy/bevy_ui_picking_backend",
-    "bevy/bevy_winit",
-    "bevy/bevy_window",
-    "bevy/x11",
-    # note that the wasm example freezes since when this feature is not enabled! TODO
-    "bevy/multi_threaded",
-]
+bevy = ["dep:bevy"]
+bevy_asset = ["bevy/bevy_asset"]
 serde = ["dep:serde"]
 
 
 [dependencies.bevy]
-version = "0.17.0-rc.1"
+version = "0.17.0-rc"
 optional = true
 default-features = false
-# features = ["async_executor", "bevy_log", "bevy_state", "bevy_asset", "std"]
 
 [dependencies]
-num_enum = { version = "0.7.3", default-features = false }
 thiserror = { version = "2.0", default-features = false }
 # Bevy feature deps
-crossbeam-channel = { version = "0.5.15", optional = true, default-features = false }
-midir = { version = "0.10", optional = true }
-tinyaudio = { version = "1.1.0", optional = true }
-itertools = { version = "0.14.0", optional = true }
-rustysynth = { version = "1.3.5", optional = true }
-bevy_platform = { version = "0.17.0-rc.1", default-features = false, features = [
+bevy_platform = { version = "0.17.0-rc", optional = true, default-features = false, features = [
     "alloc",
 ] }
 serde = {version = "1.0", features = ["derive"], optional = true}
@@ -110,3 +81,28 @@ pretty_assertions = { default-features = false, features = [
 # [[example]]
 # name = "scale"
 # required-features = ["example"]
+
+# debug = ["bevy_resources"]
+# example = [
+#     "bevy_resources",
+#     "std",
+#     "bevy/bevy_color",
+#     "bevy/bevy_core_pipeline",
+#     "bevy/bevy_ui",
+#     "bevy/bevy_ui_picking_backend",
+#     "bevy/bevy_winit",
+#     "bevy/bevy_window",
+#     "bevy/x11",
+#     # note that the wasm example freezes since when this feature is not enabled! TODO
+#     "bevy/multi_threaded",
+# ]
+#
+
+# bevy_resources = [
+#     "bevy",
+#     "dep:midir",
+#     "dep:tinyaudio",
+#     "dep:itertools",
+#     "dep:rustysynth",
+#     "dep:crossbeam-channel",
+# ]
diff --git a/src/bevy/asset/midi_file.rs b/src/bevy/asset/midi_file.rs
deleted file mode 100644
index 0bcd23d..0000000
--- a/src/bevy/asset/midi_file.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-#![doc = r#"
-Asset types
-
-TODO
-"#]
-#![allow(dead_code)]
-#![allow(unused_variables)]
-
-use bevy::{
-    asset::{AssetLoader, LoadContext, io::Reader},
-    prelude::*,
-};
-
-use crate::{
-    events::LiveEvent,
-    file::ParsedMidiFile as Mf,
-    prelude::{FormatType, Timed, Timing},
-    reader::ReaderError,
-};
-
-use crate::bevy::song::MidiSong;
-
-/// Sound font asset. Wraps a midix MidiFile
-///
-/// TODO(before v4: do not wrap midix MidiFile)
-#[derive(Asset, TypePath)]
-pub struct MidiFile {
-    inner: Mf<'static>,
-}
-
-impl MidiFile {
-    /// Create a new midifile with the given inner midix MidiFile
-    pub fn new(file: Mf<'static>) -> Self {
-        Self { inner: file }
-    }
-
-    /// Get a reference to the inner midifile
-    pub fn inner(&self) -> &Mf<'static> {
-        &self.inner
-    }
-
-    /// uses owned self to make a song sendable to the synth
-    pub fn into_song(self) -> MidiSong {
-        self.inner.into()
-    }
-    /// uses reference to make a song
-    pub fn to_song(&self) -> MidiSong {
-        (&self.inner).into()
-    }
-}
-
-impl<'a> From<Mf<'a>> for MidiSong {
-    fn from(midi: Mf<'a>) -> Self {
-        let mut commands = Vec::new();
-        let tracks = midi.tracks();
-
-        // is Some if the tempo is set for the whole file.
-        // None if the format is sequentially independent
-        let file_tempo = match midi.format_type() {
-            FormatType::SequentiallyIndependent => None,
-            FormatType::Simultaneous | FormatType::SingleMultiChannel => {
-                let first_track = tracks.first().unwrap();
-                Some(first_track.info().tempo)
-            }
-        };
-
-        for track in tracks {
-            let track_tempo = file_tempo.unwrap_or(track.info().tempo);
-            let micros_per_quarter_note = track_tempo.micros_per_quarter_note();
-
-            let (micros_per_tick, offset_in_micros) = match midi.header().timing() {
-                Timing::Smpte(v) => {
-                    //µs_per_tick = 1 000 000 / (fps × ticks_per_frame)
-                    //FPS is −24/−25/−29/−30 in the high byte of division;
-                    // ticks per frame is the low byte.
-
-                    let frames_per_second = v.fps().as_division() as u32;
-                    let ticks_per_frame = v.ticks_per_frame() as u32;
-                    let ticks_per_second = frames_per_second * ticks_per_frame;
-                    let micros_per_tick = 1_000_000. / ticks_per_second as f64;
-
-                    //NOTE: if the file header uses smpte, that overrides any track smpte offset.
-                    let offset_in_micros = track
-                        .info()
-                        .smpte_offset
-                        .as_ref()
-                        .map(|offset| {
-                            if offset.fps != v.fps() {
-                                warn!(
-                                    "Header's fps({}) does not align with track's fps({}). \
-                                    The file's fps will override the track's!",
-                                    v.fps().as_f64(),
-                                    offset.fps.as_f64()
-                                );
-                            }
-                            offset.as_micros_with_override(v.fps())
-                        })
-                        .unwrap_or(0.);
-
-                    (micros_per_tick, offset_in_micros)
-                }
-                Timing::TicksPerQuarterNote(tpqn) => {
-                    // µs_per_tick = tempo_meta / TPQN
-                    // micro_seconds/quarternote * quarternote_per_tick (1/ticks per qn)
-                    let micros_per_tick =
-                        micros_per_quarter_note as f64 / tpqn.ticks_per_quarter_note() as f64;
-
-                    let offset_in_micros = track
-                        .info()
-                        .smpte_offset
-                        .as_ref()
-                        .map(|offset| offset.as_micros())
-                        .unwrap_or(0.);
-
-                    (micros_per_tick, offset_in_micros)
-                }
-            };
-
-            for event in track.events() {
-                match event.event() {
-                    LiveEvent::ChannelVoice(cv) => {
-                        let tick = event.accumulated_ticks();
-                        let micros = micros_per_tick * tick as f64;
-
-                        commands.push(Timed::new(micros as u64, *cv));
-                    }
-                    _ => {
-                        //idk
-                    }
-                }
-            }
-        }
-        MidiSong::new(commands)
-    }
-}
-
-impl<'a> From<&Mf<'a>> for MidiSong {
-    fn from(midi: &Mf<'a>) -> Self {
-        let mut commands = Vec::new();
-        let tracks = midi.tracks();
-
-        let ticks_per_qn = midi.header().timing().ticks_per_quarter_note().unwrap();
-
-        // is Some if the tempo is set for the whole file.
-        // None if the format is sequentially independent
-        let file_tempo = match midi.format_type() {
-            FormatType::SequentiallyIndependent => None,
-            FormatType::Simultaneous | FormatType::SingleMultiChannel => {
-                let first_track = tracks.first().unwrap();
-                Some(first_track.info().tempo)
-            }
-        };
-
-        for track in tracks {
-            let track_tempo = file_tempo.unwrap_or(track.info().tempo);
-            let micros_per_quarter_note = track_tempo.micros_per_quarter_note();
-
-            let (micros_per_tick, offset_in_micros) = match midi.header().timing() {
-                Timing::Smpte(v) => {
-                    //µs_per_tick = 1 000 000 / (fps × ticks_per_frame)
-                    //FPS is −24/−25/−29/−30 in the high byte of division;
-                    // ticks per frame is the low byte.
-
-                    let frames_per_second = v.fps().as_division() as u32;
-                    let ticks_per_frame = v.ticks_per_frame() as u32;
-                    let ticks_per_second = frames_per_second * ticks_per_frame;
-                    let micros_per_tick = 1_000_000. / ticks_per_second as f64;
-
-                    //NOTE: if the file header uses smpte, that overrides any track smpte offset.
-                    let offset_in_micros = track
-                        .info()
-                        .smpte_offset
-                        .as_ref()
-                        .map(|offset| {
-                            if offset.fps != v.fps() {
-                                warn!(
-                                    "Header's fps({}) does not align with track's fps({}). \
-                                    The file's fps will override the track's!",
-                                    v.fps().as_f64(),
-                                    offset.fps.as_f64()
-                                );
-                            }
-                            offset.as_micros_with_override(v.fps())
-                        })
-                        .unwrap_or(0.);
-
-                    (micros_per_tick, offset_in_micros)
-                }
-                Timing::TicksPerQuarterNote(tpqn) => {
-                    // µs_per_tick = tempo_meta / TPQN
-                    // micro_seconds/quarternote * quarternote_per_tick (1/ticks per qn)
-                    let micros_per_tick =
-                        micros_per_quarter_note as f64 / tpqn.ticks_per_quarter_note() as f64;
-
-                    let offset_in_micros = track
-                        .info()
-                        .smpte_offset
-                        .as_ref()
-                        .map(|offset| offset.as_micros())
-                        .unwrap_or(0.);
-
-                    (micros_per_tick, offset_in_micros)
-                }
-            };
-
-            for event in track.events() {
-                match event.event() {
-                    LiveEvent::ChannelVoice(cv) => {
-                        let tick = event.accumulated_ticks();
-                        let micros = micros_per_tick * tick as f64;
-
-                        commands.push(Timed::new(micros as u64, *cv));
-                    }
-                    _ => {
-                        //idk
-                    }
-                }
-            }
-        }
-        MidiSong::new(commands)
-    }
-}
-
-/// Loader for sound fonts
-#[derive(Default)]
-pub struct MidiFileLoader;
-
-impl AssetLoader for MidiFileLoader {
-    type Asset = MidiFile;
-    type Settings = ();
-    type Error = ReaderError;
-    async fn load(
-        &self,
-        reader: &mut dyn Reader,
-        _settings: &(),
-        _load_context: &mut LoadContext<'_>,
-    ) -> Result<Self::Asset, Self::Error> {
-        let mut bytes = Vec::new();
-        reader.read_to_end(&mut bytes).await.unwrap();
-
-        let inner = Mf::parse(bytes)?;
-
-        let res = MidiFile::new(inner);
-
-        Ok(res)
-    }
-
-    fn extensions(&self) -> &[&str] {
-        &["mid"]
-    }
-}
diff --git a/src/bevy/asset/mod.rs b/src/bevy/asset/mod.rs
deleted file mode 100644
index 3aaa003..0000000
--- a/src/bevy/asset/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//! asset types
-mod midi_file;
-pub use midi_file::*;
-mod sound_font;
-pub use sound_font::*;
diff --git a/src/bevy/asset/sound_font.rs b/src/bevy/asset/sound_font.rs
deleted file mode 100644
index 1968e59..0000000
--- a/src/bevy/asset/sound_font.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-#![doc = r#"
-Asset types
-
-TODO
-"#]
-
-use alloc::sync::Arc;
-use bevy_platform::prelude::*;
-use thiserror::Error;
-
-use bevy::{
-    asset::{AssetLoader, LoadContext, io::Reader},
-    prelude::*,
-};
-use rustysynth::SoundFont as Sf;
-
-/// Sound font asset
-#[derive(Asset, TypePath)]
-pub struct SoundFont {
-    pub(crate) file: Arc<Sf>,
-}
-
-impl SoundFont {
-    /// Create a new
-    fn new(file: &mut &[u8]) -> Self {
-        let sf = Sf::new(file).unwrap();
-        Self { file: Arc::new(sf) }
-    }
-}
-/// Possible errors that can be produced by [`CustomAssetLoader`]
-#[derive(Debug, Error)]
-pub enum SoundFontLoadError {
-    /// An [IO](std::io) Error
-    #[error("Could not load asset: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-/// Loader for sound fonts
-#[derive(Default)]
-pub struct SoundFontLoader;
-
-impl AssetLoader for SoundFontLoader {
-    type Asset = SoundFont;
-    type Settings = ();
-    type Error = SoundFontLoadError;
-    async fn load(
-        &self,
-        reader: &mut dyn Reader,
-        _settings: &(),
-        _load_context: &mut LoadContext<'_>,
-    ) -> Result<Self::Asset, Self::Error> {
-        let mut bytes = Vec::new();
-        info!(
-            "Loading bytes...this might take a while. If taking too long, run with --release or with opt-level = 3!"
-        );
-        reader.read_to_end(&mut bytes).await?;
-
-        info!("Loaded!");
-        let res = SoundFont::new(&mut bytes.as_slice());
-
-        Ok(res)
-    }
-
-    fn extensions(&self) -> &[&str] {
-        &["custom"]
-    }
-}
diff --git a/src/bevy/input/connection.rs b/src/bevy/input/connection.rs
deleted file mode 100644
index a956cd2..0000000
--- a/src/bevy/input/connection.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use crate::events::{FromLiveEventBytes, LiveEvent};
-use bevy::prelude::*;
-use crossbeam_channel::{Receiver, TryRecvError};
-use midir::MidiInputPort;
-
-use super::MidiInputError;
-
-/// An [`Event`] for incoming midi data.
-#[derive(Event, Debug)]
-pub struct MidiData {
-    /// Returns the timestamp of the data
-    pub stamp: Option<u64>,
-
-    /// The underlying message of the event
-    pub message: LiveEvent<'static>,
-}
-pub(crate) struct MidiInputConnection {
-    data: Receiver<MidiData>,
-    conn: midir::MidiInputConnection<()>,
-}
-
-impl MidiInputConnection {
-    pub fn new(
-        midir_input: midir::MidiInput,
-        port: &MidiInputPort,
-        port_name: &str,
-    ) -> Result<Self, MidiInputError> {
-        let (sender, receiver) = crossbeam_channel::unbounded::<MidiData>();
-
-        let conn = midir_input.connect(
-            port,
-            port_name,
-            {
-                move |timestamp, data, _| {
-                    let Ok(message) = LiveEvent::from_bytes(data) else {
-                        return;
-                    };
-                    sender
-                        .send(MidiData {
-                            stamp: Some(timestamp),
-                            message,
-                        })
-                        .unwrap();
-                }
-            },
-            (),
-        )?;
-
-        Ok(Self {
-            data: receiver,
-            conn,
-        })
-    }
-    pub fn read(&self) -> Result<MidiData, TryRecvError> {
-        self.data.try_recv()
-    }
-    pub fn close(self) -> midir::MidiInput {
-        let (listener, _) = self.conn.close();
-        listener
-    }
-}
diff --git a/src/bevy/input/error.rs b/src/bevy/input/error.rs
deleted file mode 100644
index dc75ff5..0000000
--- a/src/bevy/input/error.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use bevy::prelude::*;
-use midir::{ConnectError, ConnectErrorKind}; // XXX: do we expose this?
-use thiserror::Error;
-
-/// The [`Error`] type for midi input operations, accessible as an [`Event`].
-#[derive(Debug, Event, Error)]
-pub enum MidiInputError {
-    /// There was something wrong connecting to the input
-    #[error("Couldn't reconnect to input port: {0}")]
-    ConnectionError(ConnectErrorKind),
-
-    /// The port, passed by id, was not found.
-    #[error("Port not found (id: {0}")]
-    PortNotFound(String),
-
-    /// Something happened when refreshing the port statuses
-    #[error("Couldn't refersh input ports")]
-    PortRefreshError,
-    /// Invalid state
-    #[error("Invalid State: {0}")]
-    InvalidState(String),
-}
-impl MidiInputError {
-    pub(crate) fn invalid(msg: impl ToString) -> Self {
-        Self::InvalidState(msg.to_string())
-    }
-    pub(crate) fn port_not_found(id: impl Into<String>) -> Self {
-        Self::PortNotFound(id.into())
-    }
-}
-
-impl From<ConnectError<midir::MidiInput>> for MidiInputError {
-    fn from(value: ConnectError<midir::MidiInput>) -> Self {
-        Self::ConnectionError(value.kind())
-    }
-}
diff --git a/src/bevy/input/mod.rs b/src/bevy/input/mod.rs
deleted file mode 100644
index 675c6e0..0000000
--- a/src/bevy/input/mod.rs
+++ /dev/null
@@ -1,243 +0,0 @@
-#![doc = r#"
-a plugin and types for handling MIDI input
-"#]
-use crossbeam_channel::TryRecvError;
-
-mod connection;
-pub use connection::*;
-
-mod error;
-pub use error::*;
-
-mod plugin;
-pub use plugin::*;
-
-use bevy::prelude::*;
-use midir::MidiInputPort;
-
-use crate::bevy::settings::MidiSettings;
-
-// you can't actually have multiple MidiInputs on one device, it's really strange.
-enum MidiInputState {
-    Listening(midir::MidiInput),
-    Active(MidiInputConnection),
-}
-/// SAFETY: This applies to linux alsa.
-///
-/// There is only one instance of MidiInput at any time using this crate.
-///
-/// However, this may not satisfy the requirements for safety. If another instance of
-/// MidiInput exists in the external program, then UB is possible.
-///
-/// Therefore, the assumption is, that when using this crate, that the user
-/// will NOT instantiate another [`midir::MidiInput`] at any point while
-/// [`MidiInput`] has been inserted as a resource
-unsafe impl Sync for MidiInputState {}
-unsafe impl Send for MidiInputState {}
-
-/// The central resource for interacting with midi inputs
-///
-/// `MidiInput` does many things:
-/// - Fetches a list of ports with connected midi devices
-/// - Allows one to connect to a particular midi device and read output
-/// - Close that connection and search for other devices
-#[derive(Resource)]
-pub struct MidiInput {
-    settings: MidiSettings,
-    state: Option<MidiInputState>,
-    ports: Vec<MidiInputPort>,
-}
-
-/// SAFETY:
-///
-/// `JsValue`s in WASM cannot be `Send`: <https://github.com/rustwasm/wasm-bindgen/pull/955>
-///
-/// Quote:
-/// > The JsValue type wraps a slab/heap of js objects which is managed by
-/// > the wasm-bindgen shim, and everything here is not actually able to cross
-/// > any thread boundaries.
-///
-/// Therefore, `MidiOutput` nor `MidiInput` should not be able to implement Send and Sync.
-///
-/// HOWEVER: Because the main scheduler does not run on worker threads, it is safe,
-/// for the wasm target, to implement Send (until this issue is resolved.)
-/// <https://github.com/bevyengine/bevy/issues/4078>
-#[cfg(all(target_arch = "wasm32", target_os = "unknown", feature = "web"))]
-unsafe impl Send for MidiInput {}
-/// SAFETY:
-///
-/// See [`MidiInput`]'s Send implementation
-#[cfg(all(target_arch = "wasm32", target_os = "unknown", feature = "web"))]
-unsafe impl Sync for MidiInput {}
-
-impl MidiInput {
-    /// Creates a new midi input with the provided settings. This is done automatically
-    /// by [`MidiInputPlugin`].
-    pub fn new(settings: MidiSettings) -> Self {
-        let listener = match midir::MidiInput::new(settings.client_name) {
-            Ok(input) => input,
-            Err(e) => {
-                panic!("Error initializing midi input! {e:?}");
-            }
-        };
-        let ports = listener.ports();
-        Self {
-            state: Some(MidiInputState::Listening(listener)),
-            settings,
-            ports,
-        }
-    }
-
-    /// Return a list of ports updated since calling [`MidiInput::new`] or
-    /// [`MidiInput::refresh_ports`]
-    pub fn ports(&self) -> &[MidiInputPort] {
-        &self.ports
-    }
-    /// Attempts to connects to the port at the given index returned by [`MidiInput::ports`]
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - If the index is out of bounds
-    /// - An input connection cannot be established
-    pub fn connect_to_index(&mut self, index: usize) -> Result<(), MidiInputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiInputState::Active(_)))
-        {
-            return Err(MidiInputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let Some(port) = self.ports.get(index) else {
-            return Err(MidiInputError::port_not_found(
-                "Port was not found at {index}!",
-            ));
-        };
-
-        let MidiInputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-
-        self.state = Some(MidiInputState::Active(
-            MidiInputConnection::new(listener, port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-
-    /// A method you should call if [`MidiInput::is_listening`] and [`MidiInput::is_active`] are both false.
-    pub fn reset(&mut self) {
-        let listener = match midir::MidiInput::new(self.settings.client_name) {
-            Ok(input) => input,
-            Err(e) => {
-                error!("Failed to reset listening state! {e:?}");
-                return;
-            }
-        };
-        self.state = Some(MidiInputState::Listening(listener));
-    }
-    /// Attempts to connects to the passed port
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - An input connection cannot be established
-    pub fn connect_to_port(&mut self, port: &MidiInputPort) -> Result<(), MidiInputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiInputState::Active(_)))
-        {
-            return Err(MidiInputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let MidiInputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-
-        self.state = Some(MidiInputState::Active(
-            MidiInputConnection::new(listener, port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-    /// Attempts to connects to the passed port
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - If the port ID cannot be currently found
-    ///   - Note that this case can occur if you have not refreshed ports
-    ///     and the device is no longer available.
-    /// - An input connection cannot be established
-    pub fn connect_to_id(&mut self, id: String) -> Result<(), MidiInputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiInputState::Active(_)))
-        {
-            return Err(MidiInputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let MidiInputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-        let Some(port) = listener.find_port_by_id(id.clone()) else {
-            return Err(MidiInputError::port_not_found(id));
-        };
-        self.state = Some(MidiInputState::Active(
-            MidiInputConnection::new(listener, &port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-    /// True if a device is currently connected
-    pub fn is_active(&self) -> bool {
-        self.state
-            .as_ref()
-            .is_some_and(|s| matches!(s, MidiInputState::Active(_)))
-    }
-
-    /// True if input is waiting to connect to a device
-    pub fn is_listening(&self) -> bool {
-        self.state
-            .as_ref()
-            .is_some_and(|s| matches!(s, MidiInputState::Listening(_)))
-    }
-
-    /// Refreshes the available port list
-    ///
-    /// Does nothing if [`MidiInput::is_active`] is true
-    pub fn refresh_ports(&mut self) {
-        let Some(MidiInputState::Listening(listener)) = &self.state else {
-            return;
-        };
-        self.ports = listener.ports();
-    }
-
-    /// Disconnects from the active device
-    ///
-    /// Does nothing if the [`MidiInput::is_listening`] is true.
-    pub fn disconnect(&mut self) {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiInputState::Listening(_)))
-        {
-            return;
-        }
-        let MidiInputState::Active(conn) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-        let listener = conn.close();
-        self.state = Some(MidiInputState::Listening(listener));
-    }
-
-    /// will return data if connected. Note, this CONSUMES the event.
-    ///
-    /// You will need to propagate this data out to other systems if need be.
-    pub fn read(&self) -> Result<MidiData, TryRecvError> {
-        let Some(MidiInputState::Active(conn)) = &self.state else {
-            return Err(TryRecvError::Disconnected);
-        };
-        conn.read()
-    }
-}
diff --git a/src/bevy/input/plugin.rs b/src/bevy/input/plugin.rs
deleted file mode 100644
index 59a1258..0000000
--- a/src/bevy/input/plugin.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use crate::bevy::settings::MidiSettings;
-
-use super::MidiInput;
-use bevy::prelude::*;
-
-#[doc = r#"
-Inserts [`MidiInput`] as a resource.
-
-See [`MidiSettings`] for configuration options.
-"#]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct MidiInputPlugin {
-    /// The settings to apply to [`MidiInput`] on instantiation.
-    pub settings: MidiSettings,
-}
-
-impl Plugin for MidiInputPlugin {
-    fn build(&self, app: &mut App) {
-        app.insert_resource(MidiInput::new(self.settings));
-    }
-}
diff --git a/src/bevy/mod.rs b/src/bevy/mod.rs
deleted file mode 100644
index b923042..0000000
--- a/src/bevy/mod.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-#![doc = r#"
-Bevy plugin that uses [`midix`](https://crates.io/crates/midix),
-[`midir`](https://github.com/Boddlnagg/midir), and a [`rustysynth`](https://github.com/sinshu/rustysynth) fork to play midi sounds!
-
-Read from MIDI devices, MIDI files, and programmable input, and output to user audio with a soundfont!
-
-## Features
-- Enable `web` for WASM compatibility
-
-## Example
-```rust, no_run
-use std::time::Duration;
-use bevy_platform::prelude::*;use bevy::{
-    log::{Level, LogPlugin},
-    prelude::*,
-};
-use midix::prelude::*;
-fn main() {
-    App::new()
-        .add_plugins((
-            DefaultPlugins.set(LogPlugin {
-                level: Level::INFO,
-                ..default()
-            }),
-            MidiPlugin {
-                input: None,
-                ..Default::default()
-            },
-        ))
-        .add_systems(Startup, load_sf2)
-        .add_systems(Update, scale_me)
-        .run();
-}
-/// Take a look here for some soundfonts:
-///
-/// <https://sites.google.com/site/soundfonts4u/>
-fn load_sf2(asset_server: Res<AssetServer>, mut synth: ResMut<Synth>) {
-    synth.use_soundfont(asset_server.load("soundfont.sf2"));
-}
-
-struct Scale {
-    timer: Timer,
-    current_key: Key,
-    note_on: bool,
-    forward: bool,
-    incremented_by: u8,
-    max_increment: u8,
-}
-
-impl Scale {
-    pub fn calculate_next_key(&mut self) {
-        if self.forward {
-            if self.incremented_by == self.max_increment {
-                self.forward = false;
-                self.incremented_by -= 1;
-                self.current_key -= 1;
-            } else {
-                self.incremented_by += 1;
-                self.current_key += 1;
-            }
-        } else if self.incremented_by == 0 {
-            self.forward = true;
-            self.incremented_by += 1;
-            self.current_key += 1;
-        } else {
-            self.incremented_by -= 1;
-            self.current_key -= 1;
-        }
-    }
-}
-
-impl Default for Scale {
-    fn default() -> Self {
-        let timer = Timer::new(Duration::from_millis(200), TimerMode::Repeating);
-        Scale {
-            timer,
-            current_key: Key::new(Note::C, Octave::new(2)),
-            note_on: true,
-            forward: true,
-            incremented_by: 0,
-            max_increment: 11,
-        }
-    }
-}
-
-fn scale_me(synth: Res<Synth>, time: Res<Time>, mut scale: Local<Scale>) {
-    // don't do anything until the soundfont has been loaded
-    if !synth.is_ready() {
-        return;
-    }
-    scale.timer.tick(time.delta());
-    if !scale.timer.just_finished() {
-        return;
-    }
-    if scale.note_on {
-        //play note on
-        _ = synth.push_event(ChannelVoiceMessage::new(
-            Channel::One,
-            VoiceEvent::note_on(scale.current_key, Velocity::MAX),
-        ));
-    } else {
-        //turn off the note
-        _ = synth.push_event(ChannelVoiceMessage::new(
-            Channel::One,
-            VoiceEvent::note_off(scale.current_key, Velocity::MAX),
-        ));
-        scale.calculate_next_key()
-    }
-
-    scale.note_on = !scale.note_on;
-}
-```
-"#]
-#![warn(missing_docs)]
-
-use bevy::prelude::*;
-
-use crate::bevy::asset::{MidiFile, MidiFileLoader};
-
-//pub mod asset;
-// pub mod input;
-// pub mod output;
-//pub mod plugin;
-// pub mod settings;
-// pub mod synth;
-
-pub mod song;
-
-// /// Commonly re-exported types
-// pub mod prelude {
-//     pub use crate::bevy::{input::*, output::*, plugin::*, settings::*, song::*, synth::*};
-
-//     #[cfg(feature = "std")]
-//     pub use crate::bevy::asset::*;
-// }
-
-/// Includes the miminal working components
-/// of `midix`
-///
-/// This includes asset loaders for [`MidiFile`]
-pub struct MidixMinimalPlugin;
-
-impl Plugin for MidixMinimalPlugin {
-    fn build(&self, app: &mut App) {
-        app.init_asset_loader::<MidiFileLoader>()
-            .init_asset::<MidiFile>();
-
-        //todod
-    }
-}
diff --git a/src/bevy/output/connection.rs b/src/bevy/output/connection.rs
deleted file mode 100644
index 764062c..0000000
--- a/src/bevy/output/connection.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use crate::MidiMessageBytes;
-use bevy::prelude::*;
-use midir::{MidiOutputPort, SendError};
-
-use super::MidiOutputError;
-
-pub(crate) struct MidiOutputConnection {
-    conn: midir::MidiOutputConnection,
-}
-
-impl MidiOutputConnection {
-    pub fn new(
-        midir_input: midir::MidiOutput,
-        port: &MidiOutputPort,
-        port_name: &str,
-    ) -> Result<Self, MidiOutputError> {
-        let conn = midir_input.connect(port, port_name)?;
-
-        Ok(Self { conn })
-    }
-    pub fn send(&mut self, message: impl Into<MidiMessageBytes>) -> Result<(), SendError> {
-        let mut buf = [0; 3];
-        let mut message: MidiMessageBytes = message.into();
-        let wrote = message.write_into(&mut buf);
-        self.conn.send(&buf[..wrote])?;
-        Ok(())
-    }
-    pub fn close(self) -> midir::MidiOutput {
-        self.conn.close()
-    }
-}
diff --git a/src/bevy/output/error.rs b/src/bevy/output/error.rs
deleted file mode 100644
index 77a3682..0000000
--- a/src/bevy/output/error.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use bevy::prelude::*;
-use midir::{ConnectError, ConnectErrorKind}; // XXX: do we expose this?
-use thiserror::Error;
-
-/// The [`Error`] type for midi input operations, accessible as an [`Event`].
-#[derive(Debug, Event, Error)]
-pub enum MidiOutputError {
-    /// There was something wrong connecting to the input
-    #[error("Couldn't reconnect to input port: {0}")]
-    ConnectionError(ConnectErrorKind),
-
-    /// The port, passed by id, was not found.
-    #[error("Port not found (id: {0}")]
-    PortNotFound(String),
-
-    /// Something happened when refreshing the port statuses
-    #[error("Couldn't refersh input ports")]
-    PortRefreshError,
-    /// Invalid state
-    #[error("Invalid State: {0}")]
-    InvalidState(String),
-}
-impl MidiOutputError {
-    pub(crate) fn invalid(msg: impl ToString) -> Self {
-        Self::InvalidState(msg.to_string())
-    }
-    pub(crate) fn port_not_found(id: impl Into<String>) -> Self {
-        Self::PortNotFound(id.into())
-    }
-}
-
-impl From<ConnectError<midir::MidiOutput>> for MidiOutputError {
-    fn from(value: ConnectError<midir::MidiOutput>) -> Self {
-        Self::ConnectionError(value.kind())
-    }
-}
diff --git a/src/bevy/output/mod.rs b/src/bevy/output/mod.rs
deleted file mode 100644
index 0e5195b..0000000
--- a/src/bevy/output/mod.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-#![doc = r#"
-A plugin and types for handling MIDI output
-"#]
-
-mod connection;
-use connection::*;
-
-mod error;
-pub use error::*;
-
-mod plugin;
-pub use plugin::*;
-
-use bevy::prelude::*;
-use midir::{MidiOutputPort, SendError};
-
-use crate::{MidiMessageBytes, bevy::settings::MidiSettings};
-
-enum MidiOutputState {
-    Listening(midir::MidiOutput),
-    Active(MidiOutputConnection),
-}
-/// SAFETY: This applies to linux alsa.
-///
-/// There is only one instance of MidiOutput at any time using this crate.
-///
-/// However, this may not satisfy the requirements for safety. If another instance of
-/// MidiOutput exists in the external program, then UB is possible.
-///
-/// Therefore, the assumption is, that when using this crate, that the user
-/// will NOT instantiate another [`midir::MidiOutput`] at any point while
-/// [`MidiOutput`] has been inserted as a resource
-unsafe impl Sync for MidiOutputState {}
-
-/// The central resource for interacting with midi output devices
-///
-/// `MidiOutput` does many things:
-/// - Fetches a list of ports with connected midi devices
-/// - Allows one to connect to a particular midi device and send output
-/// - Close that connection and search for other devices
-#[derive(Resource)]
-pub struct MidiOutput {
-    settings: MidiSettings,
-    state: Option<MidiOutputState>,
-    ports: Vec<MidiOutputPort>,
-}
-
-/// SAFETY:
-///
-/// `JsValue`s in WASM cannot be `Send`: <https://github.com/rustwasm/wasm-bindgen/pull/955>
-///
-/// Quote:
-/// > The JsValue type wraps a slab/heap of js objects which is managed by
-/// > the wasm-bindgen shim, and everything here is not actually able to cross
-/// > any thread boundaries.
-///
-/// Therefore, `MidiOutput` nor `MidiInput` should not be able to implement Send and Sync.
-///
-/// HOWEVER: Because the main scheduler does not run on worker threads, it is safe,
-/// for the wasm target, to implement Send (until this issue is resolved.)
-/// <https://github.com/bevyengine/bevy/issues/4078>
-#[cfg(all(target_arch = "wasm32", target_os = "unknown", feature = "web"))]
-unsafe impl Send for MidiOutput {}
-/// SAFETY:
-///
-/// See [`MidiOutput`]'s Send implementation
-#[cfg(all(target_arch = "wasm32", target_os = "unknown", feature = "web"))]
-unsafe impl Sync for MidiOutput {}
-
-impl MidiOutput {
-    /// Creates a new midi output with the provided settings. This is done automatically
-    /// by [`MidiOutputPlugin`].
-    pub fn new(settings: MidiSettings) -> Self {
-        let listener = match midir::MidiOutput::new(settings.client_name) {
-            Ok(output) => output,
-            Err(e) => {
-                panic!("Error initializing midi output! {e:?}");
-            }
-        };
-        let ports = listener.ports();
-        Self {
-            state: Some(MidiOutputState::Listening(listener)),
-            settings,
-            ports,
-        }
-    }
-
-    /// Return a list of ports updated since calling [`MidiOutput::new`] or
-    /// [`MidiOutput::refresh_ports`]
-    pub fn ports(&self) -> &[MidiOutputPort] {
-        &self.ports
-    }
-    /// Attempts to connects to the port at the given index returned by [`MidiOutput::ports`]
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - If the index is out of bounds
-    /// - An output connection cannot be established
-    pub fn connect_to_index(&mut self, index: usize) -> Result<(), MidiOutputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiOutputState::Active(_)))
-        {
-            return Err(MidiOutputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let Some(port) = self.ports.get(index) else {
-            return Err(MidiOutputError::port_not_found(
-                "Port was not found at {index}!",
-            ));
-        };
-
-        let MidiOutputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-
-        self.state = Some(MidiOutputState::Active(
-            MidiOutputConnection::new(listener, port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-
-    /// A method you should call if [`MidiOutput::is_listening`] and [`MidiOutput::is_active`] are both false.
-    pub fn reset(&mut self) {
-        let listener = match midir::MidiOutput::new(self.settings.client_name) {
-            Ok(output) => output,
-            Err(e) => {
-                error!("Failed to reset listening state! {e:?}");
-                return;
-            }
-        };
-        self.state = Some(MidiOutputState::Listening(listener));
-    }
-    /// Attempts to connects to the passed port
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - An output connection cannot be established
-    pub fn connect_to_port(&mut self, port: &MidiOutputPort) -> Result<(), MidiOutputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiOutputState::Active(_)))
-        {
-            return Err(MidiOutputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let MidiOutputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-
-        self.state = Some(MidiOutputState::Active(
-            MidiOutputConnection::new(listener, port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-    /// Attempts to connects to the passed port
-    ///
-    /// # Errors
-    /// - If already connected to a device
-    /// - If the port ID cannot be currently found
-    ///   - Note that this case can occur if you have not refreshed ports
-    ///     and the device is no longer available.
-    /// - An output connection cannot be established
-    pub fn connect_to_id(&mut self, id: String) -> Result<(), MidiOutputError> {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiOutputState::Active(_)))
-        {
-            return Err(MidiOutputError::invalid(
-                "Cannot connect: not currently active!",
-            ));
-        }
-        let MidiOutputState::Listening(listener) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-        let Some(port) = listener.find_port_by_id(id.clone()) else {
-            return Err(MidiOutputError::port_not_found(id));
-        };
-        self.state = Some(MidiOutputState::Active(
-            MidiOutputConnection::new(listener, &port, self.settings.port_name).unwrap(),
-        ));
-        Ok(())
-    }
-    /// True if a device is currently connected
-    pub fn is_active(&self) -> bool {
-        self.state
-            .as_ref()
-            .is_some_and(|s| matches!(s, MidiOutputState::Active(_)))
-    }
-
-    /// True if output is waiting to connect to a device
-    pub fn is_listening(&self) -> bool {
-        self.state
-            .as_ref()
-            .is_some_and(|s| matches!(s, MidiOutputState::Listening(_)))
-    }
-
-    /// Refreshes the available port list
-    ///
-    /// Does nothing if [`MidiOutput::is_active`] is true
-    pub fn refresh_ports(&mut self) {
-        let Some(MidiOutputState::Listening(listener)) = &self.state else {
-            return;
-        };
-        self.ports = listener.ports();
-    }
-
-    /// Disconnects from the active device
-    ///
-    /// Does nothing if the [`MidiOutput::is_listening`] is true.
-    pub fn disconnect(&mut self) {
-        if self
-            .state
-            .as_ref()
-            .is_none_or(|s| matches!(s, MidiOutputState::Listening(_)))
-        {
-            return;
-        }
-        let MidiOutputState::Active(conn) = self.state.take().unwrap() else {
-            unreachable!()
-        };
-        let listener = conn.close();
-        self.state = Some(MidiOutputState::Listening(listener));
-    }
-
-    /// Sends valid midi bytes to the midi output.
-    ///
-    /// Errors if [`MidiOutput::is_listening`] is true.
-    pub fn send(&mut self, message: impl Into<MidiMessageBytes>) -> Result<(), SendError> {
-        let Some(MidiOutputState::Active(conn)) = &mut self.state else {
-            return Err(SendError::Other("Disconnected."));
-        };
-        conn.send(message)
-    }
-}
diff --git a/src/bevy/output/plugin.rs b/src/bevy/output/plugin.rs
deleted file mode 100644
index 5c80403..0000000
--- a/src/bevy/output/plugin.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use super::{MidiOutput, MidiSettings};
-use bevy::prelude::*;
-
-#[doc = r#"
-Inserts [`MidiOutput`] as a resource.
-
-See [`MidiSettings`] for configuration options.
-"#]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct MidiOutputPlugin {
-    /// The settings to apply to [`MidiOutput`] on instantiation.
-    pub settings: MidiSettings,
-}
-
-impl Plugin for MidiOutputPlugin {
-    fn build(&self, app: &mut App) {
-        app.insert_resource(MidiOutput::new(self.settings));
-    }
-}
diff --git a/src/bevy/plugin.rs b/src/bevy/plugin.rs
deleted file mode 100644
index a0a2a05..0000000
--- a/src/bevy/plugin.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-#![doc = r#"
-Module for the [`MidiPlugin`]
-"#]
-use bevy::prelude::*;
-
-use crate::bevy::{
-    input::MidiInputPlugin,
-    output::MidiOutputPlugin,
-    settings::MidiSettings,
-    synth::{SynthParams, SynthPlugin},
-};
-
-#[cfg(feature = "std")]
-use crate::bevy::asset::{MidiFile, MidiFileLoader};
-
-/// Configure the parts you want to include (input, output, synth).
-///
-/// By default, the output plugin is disabled.
-pub struct MidiPlugin {
-    /// Include the output plugin. Disabled by default
-    pub output: Option<MidiOutputPlugin>,
-    /// Include the input plugin. Enabled by default
-    pub input: Option<MidiSettings>,
-    /// Include an ingame synth. Enabled by default
-    ///
-    /// Note: synth is separate from OutputPlugin,
-    ///
-    /// though, it might be a good idea to intertwine these.
-    pub synth: Option<SynthParams>,
-}
-
-impl Default for MidiPlugin {
-    fn default() -> Self {
-        Self {
-            output: None,
-            input: Some(MidiSettings::default()),
-            synth: Some(SynthParams::default()),
-        }
-    }
-}
-
-impl Plugin for MidiPlugin {
-    fn build(&self, app: &mut App) {
-        #[cfg(feature = "std")]
-        app.init_asset_loader::<MidiFileLoader>()
-            .init_asset::<MidiFile>();
-        if let Some(settings) = self.input {
-            app.add_plugins(MidiInputPlugin { settings });
-        }
-        if let Some(output) = self.output {
-            app.add_plugins(output);
-        }
-
-        if let Some(synth_plugin) = self.synth {
-            app.add_plugins(SynthPlugin {
-                params: synth_plugin,
-            });
-        }
-    }
-}
diff --git a/src/bevy/settings.rs b/src/bevy/settings.rs
deleted file mode 100644
index 48bc21e..0000000
--- a/src/bevy/settings.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Contains the [`MidiSettings`] resource
-
-use bevy::prelude::*;
-pub use midir::Ignore;
-
-/// Settings for [`MidiInputPlugin`](crate::prelude::MidiInputPlugin) and [`MidiOutputPlugin`](crate::prelude::MidiOutputPlugin).
-#[derive(Resource, Clone, Copy, Debug)]
-pub struct MidiSettings {
-    /// The name of the listening client
-    pub client_name: &'static str,
-
-    /// The port name of the listening client.
-    ///
-    /// This is appended to the port name of a connection essentially.
-    pub port_name: &'static str,
-
-    /// Describe what events you want to ignore.
-    ///
-    /// If you don't care about System Exclusive messages
-    /// (manufacturer specific messages to their proprietary devices),
-    /// set this value to [`Ignore::Sysex`].
-    pub ignore: Ignore,
-}
-
-impl Default for MidiSettings {
-    /// Assigns client name and port name to `bevy_midix`
-    ///
-    /// ignore is set to [`Ignore::None`]
-    fn default() -> Self {
-        Self {
-            client_name: "bevy_midix",
-            port_name: "bevy_midix",
-            ignore: Ignore::None,
-        }
-    }
-}
diff --git a/src/bevy/song/builder/channel.rs b/src/bevy/song/builder/channel.rs
deleted file mode 100644
index e9742e9..0000000
--- a/src/bevy/song/builder/channel.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use crate::{
-    Controller, Key, PitchBend, Program, Velocity,
-    prelude::{Channel, ChannelVoiceMessage, Timed, VoiceEvent},
-};
-
-use super::MidiSongBuilder;
-
-/// A struct provided to play a bunch of commands for one channel.
-///
-/// All time is in microseconds.
-pub struct ChannelBuilder<'a> {
-    pub(crate) builder: &'a mut MidiSongBuilder,
-    pub(crate) channel: Channel,
-}
-
-impl ChannelBuilder<'_> {
-    /// Set a program change (new voice)
-    pub fn program_change(&mut self, time: u64, program: Program) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::program_change(program)),
-        ));
-        self
-    }
-    /// Turn a note on
-    pub fn note_on(&mut self, time: u64, key: Key, velocity: Velocity) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::note_on(key, velocity)),
-        ));
-        self
-    }
-
-    /// Turn a note off
-    pub fn note_off(&mut self, time: u64, key: Key, velocity: Velocity) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::note_off(key, velocity)),
-        ));
-        self
-    }
-    /// Modify the velocity of a note after it's been played.
-    pub fn after_touch(&mut self, time: u64, key: Key, velocity: Velocity) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::after_touch(key, velocity)),
-        ));
-        self
-    }
-
-    ///Modify the controller's presets
-    pub fn control_change(&mut self, time: u64, controller: Controller) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::control_change(controller)),
-        ));
-        self
-    }
-
-    /// Change the note velocity of a whole channel at once without starting new notes
-    pub fn channel_after_touch(&mut self, time: u64, velocity: Velocity) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::channel_after_touch(velocity)),
-        ));
-        self
-    }
-    /// Bend the pitch
-    pub fn pitch_bend(&mut self, time: u64, pitch_bend: PitchBend) -> &mut Self {
-        self.builder.add(Timed::new(
-            time,
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::pitch_bend(pitch_bend)),
-        ));
-        self
-    }
-}
diff --git a/src/bevy/song/builder/mod.rs b/src/bevy/song/builder/mod.rs
deleted file mode 100644
index 76f7e47..0000000
--- a/src/bevy/song/builder/mod.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-mod channel;
-use bevy_platform::prelude::*;
-pub use channel::*;
-
-use crate::prelude::{Channel, ChannelVoiceMessage, Timed};
-
-use super::MidiSong;
-
-/// A struct to build a [`MidiSong`] programatically.
-///
-/// This struct does not consider beats per minute or anything of that sort.
-///
-/// Straight micros, delta seconds.
-#[derive(Default, Clone, Debug)]
-pub struct MidiSongBuilder {
-    accumulated_time: u64,
-    events: Vec<Timed<ChannelVoiceMessage>>,
-}
-
-impl MidiSongBuilder {
-    /// Send a lot of events to one channel efficiently
-    pub fn channel(&mut self, channel: Channel) -> ChannelBuilder<'_> {
-        ChannelBuilder {
-            builder: self,
-            channel,
-        }
-    }
-
-    /// Add a timed channel voice message. event should be in DELTA micros.
-    pub fn add(&mut self, mut event: Timed<ChannelVoiceMessage>) -> &mut Self {
-        self.accumulated_time += event.timestamp;
-        event.timestamp = self.accumulated_time;
-
-        self.events.push(event);
-        self
-    }
-    /// Add many timed channel voice messages
-    pub fn add_many(
-        &mut self,
-        events: impl IntoIterator<Item = Timed<ChannelVoiceMessage>>,
-    ) -> &mut Self {
-        self.events.extend(events.into_iter().map(|mut event| {
-            self.accumulated_time += event.timestamp;
-            event.timestamp = self.accumulated_time;
-            event
-        }));
-        self
-    }
-
-    /// Build a midi song from the provided events
-    pub fn build(self) -> MidiSong {
-        MidiSong::new(self.events)
-    }
-}
diff --git a/src/bevy/song/mod.rs b/src/bevy/song/mod.rs
deleted file mode 100644
index 0246fe1..0000000
--- a/src/bevy/song/mod.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-#![doc = r#"
-Components to make songs programatically
-"#]
-
-pub mod simple;
-use bevy_platform::prelude::*;
-pub use simple::*;
-
-mod song_writer;
-pub use song_writer::*;
-
-mod builder;
-pub use builder::*;
-
-use crate::prelude::*;
-use ::bevy::asset::uuid::Uuid;
-
-/// The identifier of a certain midi song
-#[derive(Clone, Copy, Hash, Eq, PartialEq, Debug)]
-pub struct SongId(Uuid);
-
-impl Default for SongId {
-    fn default() -> Self {
-        SongId(Uuid::new_v4())
-    }
-}
-
-/// A set of commands
-#[derive(Clone, Debug)]
-pub struct MidiSong {
-    pub(crate) id: SongId,
-    pub(crate) events: Vec<Timed<ChannelVoiceMessage>>,
-    /// If true, this will loop when sent to the synthesizer.
-    pub looped: bool,
-    /// If true, then this song starts paused.
-    pub paused: bool,
-}
-
-impl MidiSong {
-    /// Get the ID for this song.
-    ///
-    /// While MidiSong implements [`SongWriter`],
-    /// the value of ID is never optional in this case.
-    #[inline]
-    pub fn id(&self) -> SongId {
-        self.id
-    }
-    /// Returns a builder to build a midi song
-    pub fn builder() -> MidiSongBuilder {
-        MidiSongBuilder::default()
-    }
-
-    /// Create a set of commands
-    pub fn new(events: Vec<Timed<ChannelVoiceMessage>>) -> Self {
-        Self {
-            id: SongId::default(),
-            events,
-            looped: false,
-            paused: false,
-        }
-    }
-    /// Get a mutable reference to the events
-    pub fn events_mut(&mut self) -> &mut Vec<Timed<ChannelVoiceMessage>> {
-        &mut self.events
-    }
-    /// Start the song paused
-    pub fn set_paused(mut self) -> Self {
-        self.paused = true;
-        self
-    }
-
-    /// Commands should be looped
-    pub fn set_looped(mut self) -> Self {
-        self.looped = true;
-        self
-    }
-    /// set's the speed of the commands. Not absolute.
-    pub fn set_speed(mut self, speed: f64) -> Self {
-        let speed = 1. / speed;
-        self.events
-            .iter_mut()
-            .for_each(|cmd| cmd.timestamp = (cmd.timestamp as f64 * speed) as u64);
-        self
-    }
-
-    /// Returns the all timed midi events for the song.
-    ///
-    /// Not guaranteed to be sorted.
-    pub fn events(&self) -> &[Timed<ChannelVoiceMessage>] {
-        &self.events
-    }
-}
-
-impl SongWriter for MidiSong {
-    fn song_id(&self) -> Option<SongId> {
-        Some(self.id)
-    }
-    fn events(&self) -> impl Iterator<Item = Timed<ChannelVoiceMessage>> {
-        self.events.iter().copied()
-    }
-    fn looped(&self) -> bool {
-        self.looped
-    }
-    fn paused(&self) -> bool {
-        self.paused
-    }
-}
diff --git a/src/bevy/song/simple/beat.rs b/src/bevy/song/simple/beat.rs
deleted file mode 100644
index 53ffebd..0000000
--- a/src/bevy/song/simple/beat.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use crate::{
-    Key, Velocity,
-    prelude::{Channel, ChannelVoiceMessage, VoiceEvent},
-};
-
-use super::SimpleMidiSong;
-
-/// A struct to define what goes on within a beat
-pub struct Beat<'a> {
-    pub(crate) song: &'a mut SimpleMidiSong,
-    pub(crate) beat_no: u64,
-}
-
-impl<'s> Beat<'s> {
-    /// Do something at for a particular channel on this beat
-    pub fn channel<'b>(&'b mut self, channel: Channel) -> ChannelBeat<'b, 's> {
-        ChannelBeat {
-            beat: self,
-            channel,
-        }
-    }
-}
-
-/// A struct that will tell a channel to do something at a particular beat
-pub struct ChannelBeat<'b, 's> {
-    beat: &'b mut Beat<'s>,
-    channel: Channel,
-}
-
-impl<'b, 's> ChannelBeat<'b, 's> {
-    /// play a note for this channel. Does not override other notes that will be played.
-    pub fn play(self, key: Key) -> &'b mut Beat<'s> {
-        let event = ChannelVoiceMessage::new(self.channel, VoiceEvent::note_on(key, Velocity::MAX));
-
-        self.beat.song.add_event(self.beat.beat_no, event);
-        self.beat
-    }
-
-    /// play some notes for this channel. Does not override other notes that will be played.
-    pub fn play_notes<Keys>(self, keys: Keys) -> &'b mut Beat<'s>
-    where
-        Keys: IntoIterator<Item = Key>,
-    {
-        let events = keys.into_iter().map(|key| {
-            ChannelVoiceMessage::new(self.channel, VoiceEvent::note_on(key, Velocity::MAX))
-        });
-        self.beat.song.add_events(self.beat.beat_no, events);
-        self.beat
-    }
-}
diff --git a/src/bevy/song/simple/channel_settings.rs b/src/bevy/song/simple/channel_settings.rs
deleted file mode 100644
index a3bf01a..0000000
--- a/src/bevy/song/simple/channel_settings.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use crate::{
-    Key, Program, Velocity,
-    prelude::{Channel, ChannelVoiceMessage, VoiceEvent},
-};
-
-use super::{SimpleMidiSong, SimpleSection};
-
-/// A struct provided to update the settings of a particular channel for a song
-pub struct ChannelModifier<'a> {
-    pub(crate) song: &'a mut SimpleMidiSong,
-    pub(crate) channel: Channel,
-}
-
-impl<'s> ChannelModifier<'s> {
-    /// Set the voice for a channel
-    pub fn set_voice(&mut self, program: Program) -> &mut Self {
-        let preset = self.song.channel_presets.entry(self.channel).or_default();
-        preset.program = program;
-        self
-    }
-    /// Set the voice for a channel
-    pub fn set_volume(&mut self, volume: Velocity) -> &mut Self {
-        let preset = self.song.channel_presets.entry(self.channel).or_default();
-        preset.velocity = volume;
-        self
-    }
-
-    /// Do something with the channel at this beat
-    pub fn beat<'b>(&'b mut self, beat_no: u64) -> BeatChannel<'b, 's> {
-        BeatChannel {
-            channel_mod: self,
-            beat: beat_no,
-        }
-    }
-    /// Plays a section with an absolute offset from the start of the song
-    pub fn play_section(&mut self, section: &SimpleSection, beat_offset: u64) -> &mut Self {
-        for (beat, event) in section.events() {
-            let absolute_beat = *beat + beat_offset;
-            let velocity = self
-                .song
-                .channel_presets
-                .get(&self.channel)
-                .copied()
-                .unwrap_or_default()
-                .velocity;
-            //TODO: look at this
-            self.song.add_events(
-                absolute_beat,
-                event.iter().map(|e| {
-                    let event = match e {
-                        VoiceEvent::NoteOn { key, .. } => VoiceEvent::NoteOn {
-                            key: *key,
-                            velocity,
-                        },
-                        _ => *e,
-                    };
-                    ChannelVoiceMessage::new(self.channel, event)
-                }),
-            );
-        }
-        self
-    }
-}
-
-/// A struct that will tell a channel to do something at a particular beat
-pub struct BeatChannel<'b, 's> {
-    channel_mod: &'b mut ChannelModifier<'s>,
-    beat: u64,
-}
-
-impl<'b, 's> BeatChannel<'b, 's> {
-    /// play a note for this channel. Does not override other notes that will be played.
-    pub fn play(self, key: Key) -> &'b mut ChannelModifier<'s> {
-        let velocity = self
-            .channel_mod
-            .song
-            .channel_presets
-            .get(&self.channel_mod.channel)
-            .copied()
-            .unwrap_or_default()
-            .velocity;
-        let event =
-            ChannelVoiceMessage::new(self.channel_mod.channel, VoiceEvent::note_on(key, velocity));
-
-        self.channel_mod.song.add_event(self.beat, event);
-        self.channel_mod
-    }
-
-    /// play some notes for this channel. Does not override other notes that will be played.
-    pub fn play_notes<Keys>(self, keys: Keys) -> &'b mut ChannelModifier<'s>
-    where
-        Keys: IntoIterator<Item = Key>,
-    {
-        let events = keys.into_iter().map(|key| {
-            ChannelVoiceMessage::new(
-                self.channel_mod.channel,
-                VoiceEvent::note_on(key, Velocity::MAX),
-            )
-        });
-        self.channel_mod.song.add_events(self.beat, events);
-        self.channel_mod
-    }
-}
diff --git a/src/bevy/song/simple/mod.rs b/src/bevy/song/simple/mod.rs
deleted file mode 100644
index 83bac5e..0000000
--- a/src/bevy/song/simple/mod.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-//! Utils for simple song making
-use crate::prelude::*;
-use ::bevy::prelude::*;
-
-mod beat;
-pub use beat::*;
-
-mod channel_settings;
-use bevy_platform::collections::HashMap;
-pub use channel_settings::*;
-
-mod section;
-pub use section::*;
-
-use super::MidiSong;
-
-/// Presets for a channel for a simple song
-#[derive(Copy, Clone, Debug)]
-pub struct ChannelSettings {
-    /// program to use
-    pub program: Program,
-    /// how loud is it
-    pub velocity: Velocity,
-}
-impl Default for ChannelSettings {
-    fn default() -> Self {
-        Self {
-            program: Program::new(1).unwrap(),
-            velocity: Velocity::MAX,
-        }
-    }
-}
-
-/// A builder designed to make simple songs.
-///
-/// Add a few notes, and then call [`SimpleMidiSong::build`] to get a [`MidiSong`]
-///
-/// Playing using the beat method, you can play a single tone for a whole beat.
-///
-/// it will handle the rest.
-pub struct SimpleMidiSong {
-    beats_per_minute: f64,
-
-    pub(crate) channel_presets: HashMap<Channel, ChannelSettings>,
-
-    beats: HashMap<u64, Vec<ChannelVoiceMessage>>,
-    last_beat: u64,
-}
-
-impl SimpleMidiSong {
-    /// Creates a new simple song with a bpm.
-    ///
-    /// Beats per measure isn't needed. Simple song!
-    pub fn new(beats_per_minute: f64) -> Self {
-        Self {
-            beats_per_minute,
-            channel_presets: Default::default(),
-            beats: Default::default(),
-            last_beat: 0,
-        }
-    }
-
-    /// Set values for a channel
-    pub fn channel(&mut self, channel: Channel) -> ChannelModifier<'_> {
-        ChannelModifier {
-            song: self,
-            channel,
-        }
-    }
-
-    /// Do something on beat. Beats start at 1.
-    pub fn beat(&mut self, beat_no: u64) -> Beat<'_> {
-        Beat {
-            song: self,
-            beat_no,
-        }
-    }
-
-    /// Add an event
-    pub fn add_event(&mut self, beat_no: u64, event: ChannelVoiceMessage) {
-        if beat_no > self.last_beat {
-            self.last_beat = beat_no
-        }
-        let current_beat = self.beats.entry(beat_no).or_default();
-        current_beat.push(event);
-    }
-
-    /// Add a set of events toa beat.
-    pub fn add_events<Msgs>(&mut self, beat_no: u64, events: Msgs)
-    where
-        Msgs: IntoIterator<Item = ChannelVoiceMessage>,
-    {
-        if beat_no > self.last_beat {
-            self.last_beat = beat_no
-        }
-        let current_beat = self.beats.entry(beat_no).or_default();
-        current_beat.extend(events);
-    }
-}
-
-impl SimpleMidiSong {
-    /// Turns this midi song into a song that can be used for the synth to handle
-    pub fn into_song(self) -> MidiSong {
-        let micros_per_beat = 60_000_000. / self.beats_per_minute;
-
-        let mut next_beat_additions = Vec::new();
-
-        // we'll add the program change for any voices set to next_beat additions
-        if !self.channel_presets.is_empty() {
-            for (channel, settings) in self.channel_presets.iter() {
-                next_beat_additions.push(ChannelVoiceMessage::new(
-                    *channel,
-                    VoiceEvent::program_change(settings.program),
-                ));
-            }
-        }
-
-        let mut commands = Vec::with_capacity(self.beats.len() * 6);
-
-        for i in 0..=self.last_beat {
-            let beat_no = i + 1;
-            let timestamp = i * micros_per_beat as u64;
-            let Some(events) = self.beats.get(&beat_no) else {
-                let iter = next_beat_additions
-                    .iter()
-                    .copied()
-                    .map(|nb| Timed::new(timestamp, nb))
-                    .collect::<Vec<_>>();
-
-                next_beat_additions.clear();
-                commands.extend(iter);
-                continue;
-            };
-
-            let additions_for_this_beat = next_beat_additions.clone();
-            next_beat_additions.clear();
-
-            for event in events.iter() {
-                // add off events for the next beat
-                if event.is_note_on() {
-                    let channel = event.channel();
-
-                    next_beat_additions.push(ChannelVoiceMessage::new(
-                        channel,
-                        VoiceEvent::note_off(*event.key().unwrap(), Velocity::MAX),
-                    ));
-                }
-            }
-            commands.extend(
-                additions_for_this_beat
-                    .into_iter()
-                    .chain(events.iter().copied())
-                    .map(|msg| Timed::new(timestamp, msg)),
-            );
-        }
-
-        MidiSong::new(commands)
-    }
-}
diff --git a/src/bevy/song/simple/section.rs b/src/bevy/song/simple/section.rs
deleted file mode 100644
index 904b8f9..0000000
--- a/src/bevy/song/simple/section.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use crate::{Key, Velocity, prelude::VoiceEvent};
-use bevy_platform::{collections::HashMap, prelude::*};
-
-/// Create a section that can be used for looping
-#[derive(Default)]
-pub struct SimpleSection {
-    beat: HashMap<u64, Vec<VoiceEvent>>,
-}
-impl SimpleSection {
-    /// Get a [`SectionBeat`] to do things
-    pub fn beat(&mut self, beat_no: u64) -> SectionBeat<'_> {
-        SectionBeat {
-            section: self,
-            beat_no,
-        }
-    }
-    /// get the list of voice events
-    pub fn events(&self) -> &HashMap<u64, Vec<VoiceEvent>> {
-        &self.beat
-    }
-}
-/// Configure a beat for a section
-pub struct SectionBeat<'a> {
-    section: &'a mut SimpleSection,
-    beat_no: u64,
-}
-
-impl<'a> SectionBeat<'a> {
-    /// Add one note to play for the beat
-    pub fn play(self, key: Key) -> &'a mut SimpleSection {
-        let events = self.section.beat.entry(self.beat_no).or_default();
-        events.push(VoiceEvent::note_on(key, Velocity::MAX));
-        self.section
-    }
-}
diff --git a/src/bevy/song/song_writer.rs b/src/bevy/song/song_writer.rs
deleted file mode 100644
index 2207209..0000000
--- a/src/bevy/song/song_writer.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use core::{hash::BuildHasher, iter};
-
-use crate::prelude::{Channel, ChannelVoiceMessage, Timed, VoiceEvent};
-use bevy_platform::{collections::HashMap, prelude::*};
-
-use super::SongId;
-
-/// This defines a song, a file, or otherwise
-/// that has timestamps associated with midi events.
-///
-/// this is named as such not to conflict with [`midix::MidiSource`]
-pub trait SongWriter {
-    /// Create sink commands this type.
-    fn song_id(&self) -> Option<SongId> {
-        None
-    }
-    /// A list of timed events relevant to this song
-    fn events(&self) -> impl Iterator<Item = Timed<ChannelVoiceMessage>>;
-    /// is this song looped?
-    fn looped(&self) -> bool {
-        false
-    }
-    /// Is this song paused, or does it play instantly?
-    fn paused(&self) -> bool {
-        false
-    }
-    /// Helper method that will divide events into individual channels using a hasher of the caller's choice.
-    fn divide_events_into_channels<S: BuildHasher + Default>(
-        &self,
-    ) -> HashMap<Channel, Vec<Timed<VoiceEvent>>, S> {
-        let mut map: HashMap<Channel, Vec<Timed<VoiceEvent>>, S> = HashMap::default();
-
-        for event in self.events() {
-            let voice_events = map.entry(event.event.channel()).or_default();
-            voice_events.push(Timed::new(event.timestamp, *event.event.event()));
-        }
-
-        map
-    }
-}
-
-impl SongWriter for Timed<ChannelVoiceMessage> {
-    fn events(&self) -> impl Iterator<Item = Timed<ChannelVoiceMessage>> {
-        iter::once(*self)
-    }
-}
-impl SongWriter for Vec<Timed<ChannelVoiceMessage>> {
-    fn events(&self) -> impl Iterator<Item = Timed<ChannelVoiceMessage>> {
-        self.iter().copied()
-    }
-}
-impl SongWriter for [Timed<ChannelVoiceMessage>] {
-    fn events(&self) -> impl Iterator<Item = Timed<ChannelVoiceMessage>> {
-        self.iter().copied()
-    }
-}
diff --git a/src/bevy/synth/mod.rs b/src/bevy/synth/mod.rs
deleted file mode 100644
index 39edefd..0000000
--- a/src/bevy/synth/mod.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-#![doc = r#"
-Synthesizer resources, setup and plugins
-"#]
-
-use crate::bevy::song::{SongId, SongWriter};
-use crate::prelude::{ChannelVoiceMessage, Timed};
-use bevy::prelude::*;
-use bevy_platform::collections::HashMap;
-use bevy_platform::sync::Mutex;
-use crossbeam_channel::{SendError, Sender};
-use thiserror::Error;
-use tinyaudio::OutputDevice;
-
-#[cfg(feature = "std")]
-use crate::bevy::prelude::SoundFont;
-
-mod plugin;
-pub use plugin::*;
-
-mod sink;
-pub(crate) use sink::*;
-
-enum SynthState {
-    NotLoaded,
-    #[cfg(feature = "std")]
-    LoadHandle {
-        sound_font: Handle<SoundFont>,
-    },
-    #[allow(dead_code)]
-    Loaded {
-        synth_channel: Sender<ChannelVoiceMessage>,
-        /// the sink channel will process delayed events and interface with the synth channel directly
-        sink_channel: Sender<SinkCommand>,
-    },
-}
-
-/// Errors related to synthing
-#[derive(Error, Debug)]
-pub enum SynthError {
-    /// The synthesizer isn't ready yet (soundfont not loaded)
-    #[error("The synthesizer isn't ready yet (soundfont not loaded)")]
-    NotReady,
-
-    /// The [`SongId`] passed into [`Synth::play`] or [`Synth::pause`] was not found.
-    #[error("The Song with id {0:?} was not found")]
-    SongNotFound(SongId),
-    /// Disconnected from sink. This is usually because the thread panicked somehow.
-    ///
-    /// If this is unexpected, please file an issue with logs!
-    #[error("The sink has disconnected")]
-    SinkDisconnected,
-    /// Disconnected from synth. This is usually because the thread panicked somehow.
-    ///
-    /// If this is unexpected, please file an issue with logs!
-    #[error("The synth has disconnected")]
-    SynthDisconnected,
-}
-
-impl From<SendError<SinkCommand>> for SynthError {
-    fn from(_value: SendError<SinkCommand>) -> Self {
-        Self::SinkDisconnected
-    }
-}
-
-impl From<SendError<ChannelVoiceMessage>> for SynthError {
-    fn from(_value: SendError<ChannelVoiceMessage>) -> Self {
-        Self::SynthDisconnected
-    }
-}
-
-/// Contains information about a song that is kept in the synth's memory
-pub struct StoredSong {
-    /// The events for the stored song
-    pub events: Vec<Timed<ChannelVoiceMessage>>,
-    /// Are these events supposed to loop?
-    pub looped: bool,
-}
-
-/// Plays audio commands with the provided soundfont
-///
-/// Pass the synth midi events via the `Synth::handle_event` method
-///
-/// see [`ChannelVoiceMessage`] for the list of options
-#[derive(Resource)]
-pub struct Synth {
-    #[allow(dead_code)]
-    params: SynthParams,
-    synthesizer: SynthState,
-    store: HashMap<SongId, StoredSong>,
-    _device: Option<Mutex<OutputDevice>>,
-}
-
-impl Synth {
-    /// Create a new synth given the following parameters:
-    ///
-    /// 1. The number of output channels
-    ///
-    /// A good default is 2? I actually don't know
-    ///
-    /// 2. The sampling rate for the audio font (if this needs more info, please file an issue for docs)
-    ///
-    /// A good default is 44100
-    ///
-    /// 3. The sample count for each channel
-    ///
-    /// A good default is 441
-    pub fn new(params: SynthParams) -> Self {
-        Self {
-            params,
-            ..Default::default()
-        }
-    }
-
-    /// Send an event for the synth to play instantly
-    ///
-    /// # Errors
-    ///
-    /// If the synth is not ready for commands. See [`Synth::is_ready`]
-    pub fn push_event(&self, event: ChannelVoiceMessage) -> Result<(), SynthError> {
-        let SynthState::Loaded { synth_channel, .. } = &self.synthesizer else {
-            error!("An event was passed to the synth, but the soundfont has not been loaded!");
-            return Err(SynthError::NotReady);
-        };
-        synth_channel.send(event)?;
-        Ok(())
-    }
-    /// Send a single event for the synth to play instantly
-    ///
-    /// # Errors
-    ///
-    /// If the synth is not ready for commands. See [`Synth::is_ready`]
-    pub fn push_timed_event(&self, event: Timed<ChannelVoiceMessage>) -> Result<(), SynthError> {
-        let SynthState::Loaded { sink_channel, .. } = &self.synthesizer else {
-            error!("An event was passed to the synth, but the soundfont has not been loaded!");
-            return Err(SynthError::NotReady);
-        };
-        sink_channel.send(SinkCommand::PlayEvent(event))?;
-        Ok(())
-    }
-
-    /// Play a song.
-    ///
-    /// TODO: only plays from beginning
-    pub fn play(&self, id: SongId) -> Result<(), SynthError> {
-        let Some(song) = self.store.get(&id) else {
-            return Err(SynthError::SongNotFound(id));
-        };
-        let SynthState::Loaded { sink_channel, .. } = &self.synthesizer else {
-            error!("An event was passed to the synth, but the soundfont has not been loaded!");
-            return Err(SynthError::NotReady);
-        };
-        sink_channel.send(SinkCommand::NewSong {
-            id,
-            looped: song.looped,
-            commands: song.events.clone(),
-        })?;
-
-        Ok(())
-    }
-
-    /// Remove a song from the store of kept songs.
-    ///
-    /// The song will still play, but pausing and playing will fail.
-    ///
-    /// returns the underlying song when dropped
-    pub fn drop(&mut self, song: &SongId) -> Result<StoredSong, SynthError> {
-        self.store
-            .remove(song)
-            .ok_or(SynthError::SongNotFound(*song))
-    }
-
-    /// Push something that makes the synth do things.
-    ///
-    /// Returns a songid IF it already has one, or IF one was generated (because of looping)
-    ///
-    /// # Errors
-    ///
-    /// If the synth is not ready for commands. See [`Synth::is_ready`]
-    pub fn push_audio(&mut self, song: impl SongWriter) -> Result<SongId, SynthError> {
-        let SynthState::Loaded { sink_channel, .. } = &self.synthesizer else {
-            error!("An event was passed to the synth, but the soundfont has not been loaded!");
-            return Err(SynthError::NotReady);
-        };
-
-        let id = song.song_id().unwrap_or_default();
-
-        let looped = song.looped();
-
-        self.store.insert(
-            id,
-            StoredSong {
-                events: song.events().collect(),
-                looped,
-            },
-        );
-
-        if !song.paused() {
-            sink_channel.send(SinkCommand::NewSong {
-                id,
-                looped,
-                commands: song.events().collect(),
-            })?;
-        }
-
-        Ok(id)
-    }
-
-    /// Stop a certain song from playing.
-    ///
-    /// The synth will continue to hold the song. Call [`Synth::drop`] if it should
-    /// also be removed from memory.
-    ///
-    /// If stop_voices is false, any currently playing notes will continue to be held.
-    ///
-    /// # Errors
-    ///
-    /// If the synth is not ready for commands. See [`Synth::is_ready`]
-    pub fn stop(&self, song_id: SongId, stop_voices: bool) -> Result<(), SynthError> {
-        let SynthState::Loaded { sink_channel, .. } = &self.synthesizer else {
-            error!("An event was passed to the synth, but the soundfont has not been loaded!");
-            return Err(SynthError::NotReady);
-        };
-        sink_channel.send(SinkCommand::Stop {
-            song_id: Some(song_id),
-            stop_voices,
-        })?;
-        Ok(())
-    }
-
-    /// Returns true if the sound font has been loaded!
-    pub fn is_ready(&self) -> bool {
-        matches!(self.synthesizer, SynthState::Loaded { .. })
-    }
-
-    #[cfg(feature = "std")]
-    /// Provide a handle to the soundfont file
-    pub fn use_soundfont(&mut self, sound_font: Handle<SoundFont>) {
-        self.synthesizer = SynthState::LoadHandle { sound_font };
-        self._device = None;
-    }
-}
-
-impl Default for Synth {
-    fn default() -> Self {
-        Self {
-            params: SynthParams::default(),
-            store: HashMap::default(),
-            synthesizer: SynthState::NotLoaded,
-            _device: None,
-        }
-    }
-}
diff --git a/src/bevy/synth/plugin.rs b/src/bevy/synth/plugin.rs
deleted file mode 100644
index 299b6ea..0000000
--- a/src/bevy/synth/plugin.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use crate::{bevy::synth::SynthState, prelude::ChannelVoiceMessage};
-use bevy::prelude::*;
-use bevy_platform::time::Instant;
-use crossbeam_channel::{Receiver, Sender, TryIter};
-
-#[cfg(feature = "std")]
-use bevy_platform::sync::Mutex;
-
-#[cfg(feature = "std")]
-use itertools::Itertools;
-#[cfg(feature = "std")]
-use rustysynth::{Synthesizer, SynthesizerSettings};
-#[cfg(feature = "std")]
-use tinyaudio::{OutputDeviceParameters, run_output_device};
-
-use crate::bevy::prelude::*;
-
-/// A lot of the docs for this struct have been copy/pasted from tiny_audio
-///
-/// Note that usizes are used for all params, but probably shouldn't (32 bit systems).
-/// This is because the synthesizer is using tiny_audio under the hood.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SynthParams {
-    /// Desired amount of audio channels. Must be at least one. Typical values: 1 - mono, 2 - stereo, etc.
-    /// The data provided by the call back is _interleaved_, which means that if you have two channels then
-    /// the sample layout will be like so: `LRLRLR..`, where `L` - a sample of left channel, and `R` a sample
-    /// of right channel.
-    pub channel_count: usize,
-
-    /// Amount of samples per each channel. Allows you to tweak audio latency, the more the value the more
-    /// latency will be and vice versa. Keep in mind, that your data callback must be able to render the
-    /// samples while previous portion of data is being played, otherwise you'll get a glitchy audio.
-    pub channel_sample_count: usize,
-
-    /// Sample rate of your audio data. Typical values are: 11025 Hz, 22050 Hz, 44100 Hz (default), 48000 Hz,
-    /// 96000 Hz
-    pub sample_rate: usize,
-
-    /// Enable reverb and chorus for the synthesizer
-    pub enable_reverb_and_chorus: bool,
-
-    /// Inserts an [`EventReader<ChannelVoiceMessage>`] that are messages send to the synth.. Disabled by default (queue will overflow if unused).
-    pub synth_event_reader: SynthEventOpt,
-}
-
-/// Options for reading ALL events sent to the synth
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum SynthEventOpt {
-    /// Do not insert an event reader
-    None,
-    /// Insert a [`SynthEventReceiver`], but do not insert an event writer.
-    ///
-    /// e.g. "I will handle the events myself for a single thing that needs to know"
-    ReceiverOnly,
-    /// Insert an [`EventWriter<SynthEvent>`] that will propagate events.
-    ///
-    /// Note: if you also use [`SynthEventReceiver`] in your systems, be prepared to miss
-    /// events from this writer! (the receiver does not clone a shared buffer)
-    EventWriter,
-}
-
-impl Default for SynthParams {
-    fn default() -> Self {
-        Self {
-            channel_count: 2,
-            sample_rate: 44100,
-            channel_sample_count: 441,
-            enable_reverb_and_chorus: true,
-            synth_event_reader: SynthEventOpt::None,
-        }
-    }
-}
-
-/// The plugin for handling the synthesizer
-#[derive(Default, Clone, Copy)]
-pub struct SynthPlugin {
-    /// Set params for the plugin
-    pub params: SynthParams,
-}
-
-impl Plugin for SynthPlugin {
-    fn build(&self, app: &mut App) {
-        #[cfg(feature = "std")]
-        app.init_asset::<SoundFont>()
-            .init_asset_loader::<SoundFontLoader>();
-        app.init_state::<SynthStatus>()
-            .insert_resource(Synth::new(self.params))
-            .add_systems(
-                PreUpdate,
-                (
-                    #[cfg(feature = "std")]
-                    load_audio_font.run_if(in_state(SynthStatus::ShouldLoad)),
-                    sync_states.run_if(state_out_of_sync),
-                )
-                    .chain(),
-            );
-
-        match self.params.synth_event_reader {
-            SynthEventOpt::EventWriter => {
-                app.init_resource::<SynthEventReceiver>()
-                    .add_event::<SynthEvent>()
-                    .add_systems(
-                        PreUpdate,
-                        poll_receiver.run_if(in_state(SynthStatus::Loaded)),
-                    );
-            }
-            SynthEventOpt::ReceiverOnly => {
-                app.init_resource::<SynthEventReceiver>();
-            }
-            _ => {}
-        };
-    }
-}
-
-#[derive(States, Debug, Clone, PartialEq, Eq, Hash, Copy, Default)]
-enum SynthStatus {
-    #[default]
-    NotLoaded,
-    #[cfg(feature = "std")]
-    ShouldLoad,
-    Loaded,
-}
-impl SynthState {
-    fn status_should_be(&self) -> SynthStatus {
-        match self {
-            Self::NotLoaded => SynthStatus::NotLoaded,
-            #[cfg(feature = "std")]
-            Self::LoadHandle { .. } => SynthStatus::ShouldLoad,
-            Self::Loaded { .. } => SynthStatus::Loaded,
-        }
-    }
-}
-
-impl Synth {
-    fn status_should_be(&self) -> SynthStatus {
-        self.synthesizer.status_should_be()
-    }
-}
-
-#[cfg(feature = "std")]
-fn load_audio_font(
-    receiver: Option<ResMut<SynthEventReceiver>>,
-    mut synth: ResMut<Synth>,
-    assets: Res<Assets<SoundFont>>,
-) {
-    use bevy::tasks::IoTaskPool;
-
-    let SynthState::LoadHandle { sound_font } = &synth.synthesizer else {
-        warn!(
-            "loading the audio font is out of sync. This is an issue with bevy_midix. Please file an issue!"
-        );
-        return;
-    };
-    let Some(sound_font) = assets.get(sound_font) else {
-        return;
-    };
-
-    // the synth need not know about anything but a message to play instantaneously.
-    let (synth_sender, synth_receiver) = crossbeam_channel::unbounded::<ChannelVoiceMessage>();
-    let mut synth_settings = SynthesizerSettings::new(synth.params.sample_rate as i32);
-    synth_settings.enable_reverb_and_chorus = synth.params.enable_reverb_and_chorus;
-
-    let mut synthesizer = Synthesizer::new(&sound_font.file, &synth_settings).unwrap();
-
-    let mut left = vec![0f32; synth.params.channel_sample_count];
-    let mut right = vec![0f32; synth.params.channel_sample_count];
-
-    let output_device_params = OutputDeviceParameters {
-        channels_count: synth.params.channel_count,
-        sample_rate: synth.params.sample_rate,
-        channel_sample_count: synth.params.channel_sample_count,
-    };
-
-    let _device = if let Some(mut receiver) = receiver {
-        let send = receiver.take_sender();
-        run_output_device(output_device_params, {
-            move |data| {
-                for command in synth_receiver.try_iter() {
-                    // I am uneasy about this.
-                    send.try_send(SynthEvent {
-                        received: Instant::now(),
-                        message: command,
-                    })
-                    .unwrap();
-                    let data1 = command.data_1_byte() as i32;
-                    let data2 = command.data_2_byte().unwrap_or(0) as i32;
-                    let channel = (command.status() & 0b0000_1111) as i32;
-                    let command = (command.status() & 0b1111_0000) as i32;
-                    synthesizer.process_midi_message(channel, command, data1, data2);
-                }
-                synthesizer.render(&mut left[..], &mut right[..]);
-                for (i, value) in left.iter().interleave(right.iter()).enumerate() {
-                    data[i] = *value;
-                }
-            }
-        })
-    } else {
-        run_output_device(output_device_params, {
-            move |data| {
-                for command in synth_receiver.try_iter() {
-                    let data1 = command.data_1_byte() as i32;
-                    let data2 = command.data_2_byte().unwrap_or(0) as i32;
-                    let channel = (command.status() & 0b0000_1111) as i32;
-                    let command = (command.status() & 0b1111_0000) as i32;
-                    synthesizer.process_midi_message(channel, command, data1, data2);
-                }
-                synthesizer.render(&mut left[..], &mut right[..]);
-                for (i, value) in left.iter().interleave(right.iter()).enumerate() {
-                    data[i] = *value;
-                }
-            }
-        })
-    }
-    .unwrap();
-
-    let (sink_sender, sink_receiver) = crossbeam_channel::unbounded();
-
-    let thread_pool = IoTaskPool::get();
-    thread_pool
-        .spawn(SinkTask::new(synth_sender.clone(), sink_receiver))
-        .detach();
-
-    synth.synthesizer = SynthState::Loaded {
-        synth_channel: synth_sender,
-        sink_channel: sink_sender,
-    };
-    synth._device = Some(Mutex::new(_device));
-}
-
-fn state_out_of_sync(synth: Res<Synth>, current_state: Res<State<SynthStatus>>) -> bool {
-    &synth.status_should_be() != current_state.get()
-}
-
-fn sync_states(synth: Res<Synth>, mut next_state: ResMut<NextState<SynthStatus>>) {
-    next_state.set(synth.status_should_be());
-}
-
-/// Wraps a message and timestamp upon the synth
-/// receiving a message
-#[derive(Event)]
-pub struct SynthEvent {
-    /// The instant the synth thread received the message
-    pub received: Instant,
-    /// The message in question
-    pub message: ChannelVoiceMessage,
-}
-
-/// This is a reader that will recieve commands sent to the synth.
-///
-/// You can propagate the receiver inner to an `EventWriter<SynthEvent>` if you
-/// have multiple systems that need to deal with events. Otherwise, you can use
-/// this directly and poll all the events
-#[derive(Resource, Component, Clone)]
-pub struct SynthEventReceiver {
-    // holds onto this until the synth thread spawns
-    _sender: Option<Sender<SynthEvent>>,
-    receiver: Receiver<SynthEvent>,
-}
-
-impl Default for SynthEventReceiver {
-    fn default() -> Self {
-        let (sender, receiver) = crossbeam_channel::unbounded();
-        Self {
-            _sender: Some(sender),
-            receiver,
-        }
-    }
-}
-
-impl SynthEventReceiver {
-    /// Non blocking iterator of events
-    #[inline]
-    pub fn try_iter(&self) -> TryIter<'_, SynthEvent> {
-        self.receiver.try_iter()
-    }
-
-    /// Blocking iterator of events
-    #[inline]
-    pub fn iter(&self) -> crossbeam_channel::Iter<'_, SynthEvent> {
-        self.receiver.iter()
-    }
-    /// Get a reference to the underlying receiver
-    pub fn receiver(&self) -> &Receiver<SynthEvent> {
-        &self.receiver
-    }
-    #[allow(dead_code)]
-    pub(crate) fn take_sender(&mut self) -> Sender<SynthEvent> {
-        self._sender.take().unwrap()
-    }
-}
-
-/// connects the channel with the resource
-fn poll_receiver(mut ev: EventWriter<SynthEvent>, command_receiver: Res<SynthEventReceiver>) {
-    ev.write_batch(command_receiver.receiver.try_iter());
-}
diff --git a/src/bevy/synth/sink/commands.rs b/src/bevy/synth/sink/commands.rs
deleted file mode 100644
index a6934f6..0000000
--- a/src/bevy/synth/sink/commands.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-use crate::bevy::song::SongId;
-
-/// Command the sink to do something
-pub(crate) enum SinkCommand {
-    /// Play an event in time x
-    PlayEvent(Timed<ChannelVoiceMessage>),
-    /// Play a new song
-    NewSong {
-        id: SongId,
-        looped: bool,
-        /// The associated events with the song
-        commands: Vec<Timed<ChannelVoiceMessage>>,
-    },
-    /// Stop a song
-    Stop {
-        song_id: Option<SongId>,
-        stop_voices: bool,
-    },
-}
-
-pub(crate) struct InnerCommand {
-    pub(crate) time_to_send: u64,
-    pub(crate) parent: Option<SongId>,
-    pub(crate) command: ChannelVoiceMessage,
-}
diff --git a/src/bevy/synth/sink/mod.rs b/src/bevy/synth/sink/mod.rs
deleted file mode 100644
index b71d600..0000000
--- a/src/bevy/synth/sink/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
-
-This Sink will send events to another thread that will constantly poll/flush command out to the synth.
-*/
-
-mod commands;
-pub(crate) use commands::*;
-
-mod task;
-#[allow(unused_imports)]
-pub(crate) use task::*;
diff --git a/src/bevy/synth/sink/task.rs b/src/bevy/synth/sink/task.rs
deleted file mode 100644
index f912cbc..0000000
--- a/src/bevy/synth/sink/task.rs
+++ /dev/null
@@ -1,249 +0,0 @@
-use core::{
-    iter,
-    pin::Pin,
-    task::{Context, Poll},
-    time::Duration,
-};
-
-use alloc::collections::vec_deque::VecDeque;
-use bevy_platform::{prelude::*, time::Instant};
-
-//     iter,
-//     pin::Pin,
-//     task::{Context, Poll},
-//     vec::Vec,
-// };
-
-use ::bevy::log::debug;
-/*
-
-This Sink will send events to another thread that will constantly poll/flush command out to the synth.
-*/
-use crate::prelude::*;
-use crossbeam_channel::{Receiver, Sender, TryRecvError};
-
-use crate::bevy::song::SongId;
-
-use super::{SinkCommand, commands::InnerCommand};
-
-#[derive(Default)]
-pub struct CommandQueue(VecDeque<InnerCommand>);
-
-impl CommandQueue {
-    fn queue_commands(
-        &mut self,
-        id: Option<SongId>,
-        events: impl IntoIterator<Item = Timed<ChannelVoiceMessage>>,
-        elapsed: u64,
-    ) {
-        for message in events {
-            let amt = elapsed + message.timestamp;
-
-            debug!(
-                "Message will be played in {}",
-                Duration::from_micros(amt).as_secs_f64()
-            );
-            self.push_back(InnerCommand {
-                time_to_send: amt,
-                parent: id,
-                command: message.event,
-            });
-        }
-    }
-    fn push_back(&mut self, command: InnerCommand) {
-        self.0.push_back(command);
-    }
-    fn sort(&mut self) {
-        self.0.make_contiguous().sort_by_key(|m| m.time_to_send);
-    }
-    fn front(&self) -> Option<&InnerCommand> {
-        self.0.front()
-    }
-    fn pop_front(&mut self) -> Option<InnerCommand> {
-        self.0.pop_front()
-    }
-    fn retain<F>(&mut self, f: F)
-    where
-        F: FnMut(&InnerCommand) -> bool,
-    {
-        self.0.retain(f);
-    }
-}
-
-/// This struct is essentially the glue
-/// that determines when to send messages to the synthesizer.
-///
-/// It needs its own thread because it's going to need to update its timer
-///
-/// as frequently as possible.
-pub(crate) struct SinkTask {
-    start: Instant,
-    synth_channel: Sender<ChannelVoiceMessage>,
-    commands: Receiver<SinkCommand>,
-    queue: CommandQueue,
-    /// Stored songs that are looping
-    loops: Vec<LoopedSong>,
-}
-
-struct LoopedSong {
-    id: SongId,
-    events: Vec<Timed<ChannelVoiceMessage>>,
-    last_repeated: Instant,
-    length: u64,
-}
-#[allow(dead_code)]
-impl SinkTask {
-    pub fn new(
-        synth_channel: Sender<ChannelVoiceMessage>,
-        commands: Receiver<SinkCommand>,
-    ) -> Self {
-        Self {
-            start: Instant::now(),
-            synth_channel,
-            commands,
-            queue: CommandQueue::default(),
-            loops: Vec::new(),
-        }
-    }
-
-    // make sure the commands are already sorted.
-    fn keep_looping(&mut self, id: SongId, events: Vec<Timed<ChannelVoiceMessage>>) {
-        let length = events.last().map(|e| e.timestamp).unwrap_or(0);
-        self.loops.push(LoopedSong {
-            id,
-            events,
-            last_repeated: Instant::now(),
-            length,
-        })
-    }
-
-    // song commands already be sorted, or should sort.
-    //
-    // elapsed is in micros
-    fn queue_commands(
-        &mut self,
-        id: Option<SongId>,
-        events: impl IntoIterator<Item = Timed<ChannelVoiceMessage>>,
-        elapsed: u64,
-    ) {
-        for message in events {
-            let amt = elapsed + message.timestamp;
-
-            debug!(
-                "Message will be played in {}",
-                Duration::from_micros(amt).as_secs_f64()
-            );
-            self.queue.push_back(InnerCommand {
-                time_to_send: amt,
-                parent: id,
-                command: message.event,
-            });
-        }
-    }
-}
-
-impl Future for SinkTask {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut new_messages_pushed = false;
-        // first check if there's anything in the queue
-        let elapsed = self.start.elapsed().as_micros() as u64;
-        while let Some(messages) = match self.commands.try_recv() {
-            Ok(m) => Some(m),
-            Err(e) => match e {
-                TryRecvError::Disconnected => {
-                    return Poll::Ready(());
-                }
-                _ => None,
-            },
-        } {
-            match messages {
-                SinkCommand::PlayEvent(event) => {
-                    // we will always sort. there is no guarantee that events after this aren't before/after this event.
-                    //
-                    // However, there could be a performance optimization here.
-                    new_messages_pushed = true;
-                    self.queue_commands(None, iter::once(event), elapsed);
-                }
-                SinkCommand::NewSong {
-                    id,
-                    looped,
-                    mut commands,
-                } => {
-                    if commands.is_empty() {
-                        continue;
-                    }
-                    commands.sort_by_key(|m| m.timestamp);
-
-                    new_messages_pushed = true;
-                    if looped {
-                        self.keep_looping(id, commands.clone());
-                    }
-
-                    self.queue_commands(Some(id), commands, elapsed);
-                }
-                SinkCommand::Stop {
-                    song_id,
-                    stop_voices,
-                } => {
-                    if let Some(song_id) = song_id {
-                        self.queue
-                            .retain(|command| command.parent.is_none_or(|id| id != song_id));
-                        self.loops.retain(|info| info.id != song_id);
-                    }
-                    if stop_voices {
-                        let events = Channel::all().into_iter().map(|channel| {
-                            Timed::new(
-                                0,
-                                ChannelVoiceMessage::new(
-                                    channel,
-                                    VoiceEvent::control_change(Controller::mute_all()),
-                                ),
-                            )
-                        });
-                        self.queue_commands(None, events, elapsed);
-                    }
-                }
-            }
-
-            //do something
-        }
-        if new_messages_pushed {
-            self.queue.sort();
-        }
-
-        let elapsed = self.start.elapsed().as_micros() as u64;
-
-        while self
-            .queue
-            .front()
-            .is_some_and(|first| first.time_to_send <= elapsed)
-        {
-            let message = self.queue.pop_front().unwrap();
-
-            debug!(
-                "({}) {:?}",
-                message.command.channel(),
-                message.command.event()
-            );
-
-            self.synth_channel.send(message.command).unwrap();
-        }
-
-        //finally, queue any songs that have elapsed their length
-        let mut songs_to_clone = Vec::new();
-        for info in self.loops.iter_mut() {
-            if info.last_repeated.elapsed().as_micros() as u64 >= info.length {
-                songs_to_clone.push((Some(info.id), info.events.clone()));
-                info.last_repeated = Instant::now();
-            }
-        }
-        for (id, iter) in songs_to_clone {
-            self.queue.queue_commands(id, iter, elapsed);
-        }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
-    }
-}
diff --git a/src/byte/mod.rs b/src/byte/mod.rs
index 0d36579..432894b 100644
--- a/src/byte/mod.rs
+++ b/src/byte/mod.rs
@@ -161,7 +161,7 @@ Except for Real-Time messages, new Status bytes will always command a receiver t
 even if the last message was not completed.
 "#]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct StatusByte(u8);
 
@@ -206,7 +206,7 @@ impl TryFrom<u8> for StatusByte {
 Data Byte is between [0x00 and 0x7F]
 "#]
 #[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DataByte(pub(crate) u8);
 impl Debug for DataByte {
diff --git a/src/channel.rs b/src/channel.rs
index aacf34e..8192a6a 100644
--- a/src/channel.rs
+++ b/src/channel.rs
@@ -7,18 +7,14 @@ use core::{
     ops::{Add, AddAssign, Sub, SubAssign},
 };
 
-use num_enum::{IntoPrimitive, TryFromPrimitive};
-
 use crate::message::{ChannelVoiceMessage, VoiceEvent};
 
 /// Identifies a channel for MIDI.
 ///
 /// To get this channel from a `u8`, use [`Channel::try_from_primitive`].
-#[derive(
-    Clone, Copy, PartialEq, Eq, Debug, Hash, IntoPrimitive, TryFromPrimitive, PartialOrd, Ord,
-)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 #[cfg_attr(
-    feature = "bevy_resources",
+    feature = "bevy",
     derive(bevy::prelude::Component, bevy::prelude::Reflect)
 )]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -76,6 +72,33 @@ impl Channel {
     pub const fn send_event(self, event: VoiceEvent) -> ChannelVoiceMessage {
         ChannelVoiceMessage::new(self, event)
     }
+    /// Create a `Channel` from a byte.
+    ///
+    /// 0 -> `Channel::One`
+    /// ..
+    /// 15 -> `Channel::Sixteen`
+    pub const fn try_from_byte(byte: u8) -> Option<Channel> {
+        let channel = match byte {
+            0 => Channel::One,
+            1 => Channel::Two,
+            2 => Channel::Three,
+            3 => Channel::Four,
+            4 => Channel::Five,
+            5 => Channel::Six,
+            6 => Channel::Seven,
+            7 => Channel::Eight,
+            8 => Channel::Nine,
+            9 => Channel::Ten,
+            10 => Channel::Eleven,
+            11 => Channel::Twelve,
+            12 => Channel::Thirteen,
+            13 => Channel::Fourteen,
+            14 => Channel::Fifteen,
+            15 => Channel::Sixteen,
+            _ => return None,
+        };
+        Some(channel)
+    }
 
     /// Given a status byte from some [`ChannelVoiceMessage`], perform bitwise ops
     /// to get the channel
@@ -97,7 +120,7 @@ impl Channel {
 
 impl fmt::Display for Channel {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let res: u8 = (*self).into();
+        let res: u8 = *self as u8;
         res.fmt(f)
     }
 }
diff --git a/src/controller.rs b/src/controller.rs
index a4c6d85..38bdb4c 100644
--- a/src/controller.rs
+++ b/src/controller.rs
@@ -15,7 +15,7 @@ use crate::{prelude::*, reader::ReaderError};
 /// in a "coarse" manner.
 #[non_exhaustive]
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Controller {
     /// 0x00
diff --git a/src/events/live.rs b/src/events/live.rs
index 3010a17..6142292 100644
--- a/src/events/live.rs
+++ b/src/events/live.rs
@@ -44,7 +44,7 @@ An emittable message to/from a streaming MIDI device.
 There is currently no `StreamReader` type, so this type is most often manually constructed.
 "]
 #[derive(Clone, Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub enum LiveEvent<'a> {
     /// A MIDI voice message associated with a channel
     ChannelVoice(ChannelVoiceMessage),
diff --git a/src/file/format.rs b/src/file/format.rs
index 2398dd5..c7e6b74 100644
--- a/src/file/format.rs
+++ b/src/file/format.rs
@@ -21,7 +21,7 @@ sequence number.*/
 Holds the tracks based on the supplied format
 "#]
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub enum Format<'a> {
     /// Format 0
     SingleMultiChannel(Track<'a>),
diff --git a/src/file/header.rs b/src/file/header.rs
index 25d113a..c8a4e8d 100644
--- a/src/file/header.rs
+++ b/src/file/header.rs
@@ -3,7 +3,7 @@ use crate::prelude::*;
 #[doc = r#"
    Information about the timing of the MIDI file
 "#]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct Header {
     timing: Timing,
 }
diff --git a/src/file/mod.rs b/src/file/mod.rs
index 552f606..759e116 100644
--- a/src/file/mod.rs
+++ b/src/file/mod.rs
@@ -24,15 +24,15 @@ use crate::{
 #[doc = r#"
 TODO
 "#]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct ParsedMidiFile<'a> {
     header: Header,
     format: Format<'a>,
 }
-#[cfg(feature = "bevy")]
+#[cfg(feature = "bevy_asset")]
 impl bevy::asset::Asset for ParsedMidiFile<'static> {}
 
-#[cfg(feature = "bevy")]
+#[cfg(feature = "bevy_asset")]
 impl bevy::asset::VisitAssetDependencies for ParsedMidiFile<'static> {
     fn visit_dependencies(&self, _visit: &mut impl FnMut(bevy::asset::UntypedAssetId)) {}
 }
diff --git a/src/file/track.rs b/src/file/track.rs
index 7f57b11..5e87b18 100644
--- a/src/file/track.rs
+++ b/src/file/track.rs
@@ -11,7 +11,7 @@ use crate::{
 A set of track events
 "#]
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct Track<'a> {
     info: TrackInfo<'a>,
     events: Vec<Ticked<LiveEvent<'a>>>,
@@ -73,7 +73,7 @@ impl<'a> Track<'a> {
 /// Provides information about the track
 #[allow(missing_docs)]
 #[derive(Default, Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct TrackInfo<'a> {
     pub time_signature: TimeSignature,
     pub name: Option<BytesText<'a>>,
diff --git a/src/file_repr/chunk/header.rs b/src/file_repr/chunk/header.rs
index 6ae2c89..e69eb22 100644
--- a/src/file_repr/chunk/header.rs
+++ b/src/file_repr/chunk/header.rs
@@ -113,7 +113,7 @@ impl RawHeaderChunk {
 /// This is either the number of ticks per quarter note or
 /// the alternative SMTPE format. See the [`RawHeaderChunk`] docs for more information.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub enum Timing {
     /// The midi file's delta times are defined using a tick rate per quarter note
     TicksPerQuarterNote(TicksPerQuarterNote),
@@ -124,7 +124,7 @@ pub enum Timing {
 
 /// A representation of the `tpqn` timing for a MIDI file
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct TicksPerQuarterNote {
     inner: [u8; 2],
 }
@@ -138,7 +138,7 @@ impl TicksPerQuarterNote {
 
 /// A representation of the `smpte` timing for a MIDI file
 #[derive(Debug, Clone, PartialEq, Eq, Copy)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct SmpteHeader {
     fps: SmpteFps,
     ticks_per_frame: DataByte,
diff --git a/src/file_repr/meta/mod.rs b/src/file_repr/meta/mod.rs
index f6f8265..4cc9c15 100644
--- a/src/file_repr/meta/mod.rs
+++ b/src/file_repr/meta/mod.rs
@@ -5,7 +5,6 @@ Contains types that deal with file ['MetaMessage']s
 mod tempo;
 
 use alloc::borrow::Cow;
-use num_enum::TryFromPrimitive;
 pub use tempo::*;
 mod time_signature;
 pub use time_signature::*;
@@ -99,12 +98,12 @@ impl<'a> MetaMessage<'a> {
                 }
                 //TODO: need to test thsi
                 let c = data.first().unwrap();
-                MetaMessage::MidiChannel(Channel::try_from_primitive(*c).map_err(|e| {
+                MetaMessage::MidiChannel(Channel::try_from_byte(*c).ok_or(
                     ReaderError::parse_error(
                         reader.buffer_position(),
-                        ParseError::InvalidChannel(e.number),
-                    )
-                })?)
+                        ParseError::InvalidChannel(*c),
+                    ),
+                )?)
             }
             0x21 => {
                 if data.len() != 1 {
diff --git a/src/file_repr/meta/smpte_offset.rs b/src/file_repr/meta/smpte_offset.rs
index 3666164..672c39e 100644
--- a/src/file_repr/meta/smpte_offset.rs
+++ b/src/file_repr/meta/smpte_offset.rs
@@ -2,7 +2,7 @@ use crate::{SmpteError, prelude::SmpteFps};
 
 /// A representation of a track's offset from the beginning of a midi file.
 #[derive(Clone, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct SmpteOffset {
     /// the track's fps. Note: this should be identical to a file's FPS if
     /// the file is defined in terms of `smpte`
diff --git a/src/file_repr/meta/tempo.rs b/src/file_repr/meta/tempo.rs
index 18399f6..f2d7b17 100644
--- a/src/file_repr/meta/tempo.rs
+++ b/src/file_repr/meta/tempo.rs
@@ -2,7 +2,7 @@
 ///
 /// FF 51 03 tttttt
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct Tempo(u32);
 
 impl Default for Tempo {
diff --git a/src/file_repr/meta/text.rs b/src/file_repr/meta/text.rs
index 4bf9343..4da7943 100644
--- a/src/file_repr/meta/text.rs
+++ b/src/file_repr/meta/text.rs
@@ -6,7 +6,7 @@ use crate::ParseError;
 
 /// Some text, usually identified by a ['MetaMessage'](super::MetaMessage)s
 #[derive(Clone, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct BytesText<'a> {
     inner: Cow<'a, [u8]>,
 }
diff --git a/src/file_repr/meta/time_signature.rs b/src/file_repr/meta/time_signature.rs
index eeb6c34..192e231 100644
--- a/src/file_repr/meta/time_signature.rs
+++ b/src/file_repr/meta/time_signature.rs
@@ -26,7 +26,7 @@ That is, 6/8 time (8 is 2 to the 3rd power, so this is 06 03),
 eight notated 32nd-notes per quarter-note.
 "#]
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub struct TimeSignature([u8; 4]);
 
 impl Default for TimeSignature {
diff --git a/src/file_repr/smpte.rs b/src/file_repr/smpte.rs
index a426d37..6dd9cfb 100644
--- a/src/file_repr/smpte.rs
+++ b/src/file_repr/smpte.rs
@@ -6,7 +6,7 @@
 /// - 29: dropframe 30 (30,000 frames / 1001 seconds)
 /// - 30: 30fps
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 pub enum SmpteFps {
     /// 24
     TwentyFour,
diff --git a/src/lib.rs b/src/lib.rs
index 5831cbb..2664996 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,5 @@
 #![warn(missing_docs)]
-#![cfg_attr(not(feature = "debug"), warn(clippy::print_stdout))]
+#![warn(clippy::print_stdout)]
 #![doc = include_str!("../README.md")]
 #![no_std]
 
@@ -47,12 +47,6 @@ pub use song_position_pointer::*;
 mod target;
 pub use target::*;
 
-//#[cfg(feature = "bevy_resources")]
-//pub mod bevy;
-
-// #[cfg(feature = "bevy")]
-// pub mod bevy;
-
 pub mod prelude {
     #![doc = r#"
         Common re-exports when working with `midix`
@@ -76,6 +70,6 @@ pub mod prelude {
 
     pub use core::fmt::Display;
 
-    //#[cfg(feature = "bevy_resources")]
+    //#[cfg(feature = "bevy")]
     //pub use crate::bevy::prelude::*;
 }
diff --git a/src/message/channel/mod.rs b/src/message/channel/mod.rs
index 9f89e77..9e571e4 100644
--- a/src/message/channel/mod.rs
+++ b/src/message/channel/mod.rs
@@ -23,7 +23,7 @@ pub use voice_event::*;
 #[doc = r#"
 The set of possible Channel messages
 "#]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum ChannelMessage {
     /// A channel voice message
diff --git a/src/message/channel/voice.rs b/src/message/channel/voice.rs
index f0d8a8f..7c342cd 100644
--- a/src/message/channel/voice.rs
+++ b/src/message/channel/voice.rs
@@ -16,7 +16,7 @@ use crate::{
 /// [`LiveEvent::parse`](live/enum.LiveEvent.html#method.parse) method instead and ignore all
 /// variants except for [`LiveEvent::Midi`](live/enum.LiveEvent.html#variant.Midi).
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::reflect::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::reflect::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct ChannelVoiceMessage {
     /// The MIDI channel that this event is associated with.
diff --git a/src/message/channel/voice_event.rs b/src/message/channel/voice_event.rs
index a90b973..84deb78 100644
--- a/src/message/channel/voice_event.rs
+++ b/src/message/channel/voice_event.rs
@@ -16,7 +16,7 @@ use crate::prelude::*;
 /// [`LiveEvent::parse`](live/enum.LiveEvent.html#method.parse) method instead and ignore all
 /// variants except for [`LiveEvent::Midi`](live/enum.LiveEvent.html#variant.Midi).
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum VoiceEvent {
     /// Modify the value of a MIDI controller.
diff --git a/src/message/mod.rs b/src/message/mod.rs
index 8df04e7..dbf246c 100644
--- a/src/message/mod.rs
+++ b/src/message/mod.rs
@@ -55,7 +55,7 @@ pub use time::*;
 An enumeration of all possible midi messages
 "#]
 #[derive(Debug)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum MidiMessage<'a> {
     /// A system common message
diff --git a/src/message/system/common.rs b/src/message/system/common.rs
index 397f906..ad9b4af 100644
--- a/src/message/system/common.rs
+++ b/src/message/system/common.rs
@@ -6,7 +6,7 @@ use crate::{prelude::*, utils::check_u7};
 A System Common Message, used to relay data for ALL receivers, regardless of channel.
 "#]
 #[derive(Clone, PartialEq, Eq, Debug)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum SystemCommonMessage<'a> {
     /// A system-exclusive message.
diff --git a/src/message/system/exclusive.rs b/src/message/system/exclusive.rs
index 80c753c..fca7bdc 100644
--- a/src/message/system/exclusive.rs
+++ b/src/message/system/exclusive.rs
@@ -42,7 +42,7 @@ is used for extensions called Universal Exclusive Messages.
 ```
 "#]
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SystemExclusiveMessage<'a>(Cow<'a, [u8]>);
 
diff --git a/src/message/system/mod.rs b/src/message/system/mod.rs
index 4826b68..1cab8ea 100644
--- a/src/message/system/mod.rs
+++ b/src/message/system/mod.rs
@@ -25,7 +25,7 @@ pub use exclusive::*;
 #[doc = r#"
 The set of possible System messages
 "#]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum SystemMessage<'a> {
     /// The set of common messages. Only found in MIDI files
diff --git a/src/message/system/realtime.rs b/src/message/system/realtime.rs
index 04a8c89..7958529 100644
--- a/src/message/system/realtime.rs
+++ b/src/message/system/realtime.rs
@@ -13,7 +13,7 @@ They are usually time-sensitive, get top priority and can even be transmitted in
 messages.
 "#]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum SystemRealTimeMessage {
     /// If sent, they should be sent 24 times per quarter note.
diff --git a/src/message/time.rs b/src/message/time.rs
index f548af0..063cd32 100644
--- a/src/message/time.rs
+++ b/src/message/time.rs
@@ -37,7 +37,7 @@ impl<T> Ticked<T> {
 ///
 /// This differs from `Ticked`, which does not necessarily represent itself in time.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Timed<T> {
     /// Micros
diff --git a/src/note.rs b/src/note.rs
index a7975d0..d9c03c6 100644
--- a/src/note.rs
+++ b/src/note.rs
@@ -26,7 +26,7 @@ assert_eq!(key.octave(), Octave::new(4))
 "#]
 #[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug, Hash)]
 #[cfg_attr(
-    feature = "bevy_resources",
+    feature = "bevy",
     derive(bevy::prelude::Component, bevy::prelude::Reflect)
 )]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/src/pitch_bend.rs b/src/pitch_bend.rs
index 56194d9..4baf712 100644
--- a/src/pitch_bend.rs
+++ b/src/pitch_bend.rs
@@ -8,7 +8,7 @@ use crate::prelude::*;
 ///
 /// This value is available via [`PitchBend::value`]
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct PitchBend {
     lsb: DataByte,
diff --git a/src/program.rs b/src/program.rs
index 421b34e..48d4857 100644
--- a/src/program.rs
+++ b/src/program.rs
@@ -5,7 +5,7 @@ use core::fmt;
 ///
 /// TODO docs
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Program(DataByte);
 
diff --git a/src/song_position_pointer.rs b/src/song_position_pointer.rs
index a62d657..2376189 100644
--- a/src/song_position_pointer.rs
+++ b/src/song_position_pointer.rs
@@ -13,7 +13,7 @@ where
 
 "#]
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-#[cfg_attr(feature = "bevy_resources", derive(bevy::prelude::Reflect))]
+#[cfg_attr(feature = "bevy", derive(bevy::prelude::Reflect))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SongPositionPointer {
     lsb: DataByte,
diff --git a/src/synthesizer/Cargo.toml b/src/synthesizer/Cargo.toml
deleted file mode 100644
index d95bc5c..0000000
--- a/src/synthesizer/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "midix_synth"
-version = "0.1.0-alpha"
-edition = "2024"
-authors = ["dsgallups <dsgallups@protonmail.com>"]
-description = "SoundFont compatible MIDI synthesizer for midix"
-repository = "https://github.com/dsgallups/midix"
-documentation = "https://docs.rs/midix_synth"
-readme = "README.md"
-keywords = ["midi", "audio", "synthesizer"]
-categories = ["multimedia::audio", "multimedia"]
-license = "MIT OR Apache-2.0"
-
-[dependencies]
-tracing = "0.1.41"
diff --git a/src/synthesizer/README.md b/src/synthesizer/README.md
deleted file mode 100644
index a2d2692..0000000
--- a/src/synthesizer/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# midix_synth
-
-# Overview
-This crate is **NOT READY** for use.
-
-This crate has been published to park the name, and is under active development.
-
-Most of this code, and the
-respective challenges of implementation comes
-DIRECTLY from [rustysynth v1.3.3](https://github.com/sinshu/rustysynth).
-
-This crate refactors portions of `rustysynth` to operate cohesively with `bevy_midix`.
-
-It should not be used *independently*. It's not even used by `bevy_midix` nor `midix`!
diff --git a/src/synthesizer/TODO.md b/src/synthesizer/TODO.md
deleted file mode 100644
index fad913c..0000000
--- a/src/synthesizer/TODO.md
+++ /dev/null
@@ -1,4 +0,0 @@
-Analyze the buffer sytem.
-
-See what polls the buffer, and then reverse the dependency such that
-the poller holds an internal queue.
diff --git a/src/synthesizer/src/lib.rs b/src/synthesizer/src/lib.rs
deleted file mode 100644
index 0bed5bb..0000000
--- a/src/synthesizer/src/lib.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-#![doc = include_str!("../README.md")]
-
-pub(crate) mod reader;
-pub mod soundfont;
-pub mod synthesizer;
-
-mod utils;
-
-pub mod prelude {
-    pub use crate::{
-        soundfont::{instrument::*, preset::*, *},
-        synthesizer::*,
-    };
-
-    pub(crate) use crate::{
-        reader::*,
-        soundfont::{generator::*, zone::*},
-    };
-}
diff --git a/src/synthesizer/src/reader/binary.rs b/src/synthesizer/src/reader/binary.rs
deleted file mode 100644
index 2afdf3a..0000000
--- a/src/synthesizer/src/reader/binary.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-#![allow(dead_code)]
-
-use crate::soundfont::FourCC;
-use bevy_platform::prelude::*;
-
-#[allow(unused)]
-pub struct BinaryReader {}
-
-impl BinaryReader {
-    pub fn read_i8<R: Read + ?Sized>(reader: &mut R) -> Result<i8, io::Error> {
-        let mut data: [u8; 1] = [0; 1];
-        reader.read_exact(&mut data)?;
-        Ok(i8::from_le_bytes(data))
-    }
-
-    pub fn read_u8<R: Read + ?Sized>(reader: &mut R) -> Result<u8, io::Error> {
-        let mut data: [u8; 1] = [0; 1];
-        reader.read_exact(&mut data)?;
-        Ok(u8::from_le_bytes(data))
-    }
-
-    pub fn read_i16<R: Read + ?Sized>(reader: &mut R) -> Result<i16, io::Error> {
-        let mut data: [u8; 2] = [0; 2];
-        reader.read_exact(&mut data)?;
-        Ok(i16::from_le_bytes(data))
-    }
-
-    pub fn read_u16<R: Read + ?Sized>(reader: &mut R) -> Result<u16, io::Error> {
-        let mut data: [u8; 2] = [0; 2];
-        reader.read_exact(&mut data)?;
-        Ok(u16::from_le_bytes(data))
-    }
-
-    pub fn read_i32<R: Read + ?Sized>(reader: &mut R) -> Result<i32, io::Error> {
-        let mut data: [u8; 4] = [0; 4];
-        reader.read_exact(&mut data)?;
-        Ok(i32::from_le_bytes(data))
-    }
-
-    pub fn read_u32<R: Read + ?Sized>(reader: &mut R) -> Result<u32, io::Error> {
-        let mut data: [u8; 4] = [0; 4];
-        reader.read_exact(&mut data)?;
-        Ok(u32::from_le_bytes(data))
-    }
-
-    pub fn read_i16_big_endian<R: Read + ?Sized>(reader: &mut R) -> Result<i16, io::Error> {
-        let mut data: [u8; 2] = [0; 2];
-        reader.read_exact(&mut data)?;
-        Ok(i16::from_be_bytes(data))
-    }
-
-    pub fn read_i32_big_endian<R: Read + ?Sized>(reader: &mut R) -> Result<i32, io::Error> {
-        let mut data: [u8; 4] = [0; 4];
-        reader.read_exact(&mut data)?;
-        Ok(i32::from_be_bytes(data))
-    }
-
-    pub fn read_i32_variable_length<R: Read + ?Sized>(reader: &mut R) -> Result<i32, io::Error> {
-        let mut acc: i32 = 0;
-        let mut count: i32 = 0;
-
-        loop {
-            let value = BinaryReader::read_u8(reader)? as i32;
-            acc = (acc << 7) | (value & 127);
-            if (value & 128) == 0 {
-                break;
-            }
-            count += 1;
-            if count == 4 {
-                return Err(io::Error::new(
-                    ErrorKind::InvalidData,
-                    "the length of the value must be equal to or less than 4",
-                ));
-            }
-        }
-
-        Ok(acc)
-    }
-
-    pub fn read_four_cc<R: Read + ?Sized>(reader: &mut R) -> Result<FourCC, io::Error> {
-        let mut data: [u8; 4] = [0; 4];
-        reader.read_exact(&mut data)?;
-        Ok(FourCC::from_bytes(data))
-    }
-
-    pub fn read_fixed_length_string<R: Read + ?Sized>(
-        reader: &mut R,
-        length: usize,
-    ) -> Result<String, io::Error> {
-        let mut data: Vec<u8> = vec![0; length];
-        reader.read_exact(&mut data)?;
-
-        let mut actual_length: usize = 0;
-        for value in &mut data {
-            if *value == 0 {
-                break;
-            }
-            actual_length += 1;
-        }
-
-        // Replace non-ASCII characters with '?'.
-        // Tabs and returns are preserved.
-        for value in &mut data[0..actual_length] {
-            if !(9..=126).contains(value) {
-                *value = 63; // '?'
-            }
-        }
-
-        Ok(str::from_utf8(&data[0..actual_length]).unwrap().to_string())
-    }
-
-    pub fn discard_data<R: Read + ?Sized>(reader: &mut R, size: usize) -> Result<(), io::Error> {
-        let mut data: Vec<u8> = vec![0; size];
-        reader.read_exact(&mut data)
-    }
-
-    pub fn read_wave_data<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<i16>, io::Error> {
-        let length = size / 2;
-        let mut samples: Vec<i16> = vec![0; length];
-
-        let ptr = samples.as_mut_ptr() as *mut u8;
-        let data = unsafe { slice::from_raw_parts_mut(ptr, size) };
-        reader.read_exact(data)?;
-
-        Ok(samples)
-    }
-}
diff --git a/src/synthesizer/src/reader/counter.rs b/src/synthesizer/src/reader/counter.rs
deleted file mode 100644
index 3f886b6..0000000
--- a/src/synthesizer/src/reader/counter.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use bevy_platform::prelude::*;
-pub struct ReadCounter<'a, R: Read + ?Sized> {
-    reader: &'a mut R,
-    count: usize,
-}
-
-impl<'a, R: Read + ?Sized> ReadCounter<'a, R> {
-    pub fn new(reader: &'a mut R) -> Self {
-        Self { reader, count: 0 }
-    }
-
-    pub fn bytes_read(&self) -> usize {
-        self.count
-    }
-}
-
-impl<R: Read + ?Sized> Read for ReadCounter<'_, R> {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        let len = self.reader.read(buf)?;
-        self.count += len;
-        Ok(len)
-    }
-}
diff --git a/src/synthesizer/src/reader/mod.rs b/src/synthesizer/src/reader/mod.rs
deleted file mode 100644
index c5da98f..0000000
--- a/src/synthesizer/src/reader/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod binary;
-pub use binary::*;
-mod counter;
-pub use counter::*;
diff --git a/src/synthesizer/src/soundfont/error.rs b/src/synthesizer/src/soundfont/error.rs
deleted file mode 100644
index 6b4103f..0000000
--- a/src/synthesizer/src/soundfont/error.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-use bevy_platform::prelude::*;
-use bevy_platform::prelude::*;
-/// Represents an error when loading a SoundFont.
-#[derive(Debug)]
-pub enum SoundFontError {
-    IoError(io::Error),
-    RiffChunkNotFound,
-    InvalidRiffChunkType {
-        expected: FourCC,
-        actual: FourCC,
-    },
-    ListChunkNotFound,
-    InvalidListChunkType {
-        expected: FourCC,
-        actual: FourCC,
-    },
-    ListContainsUnknownId(FourCC),
-    SampleDataNotFound,
-    UnsupportedSampleFormat,
-    SubChunkNotFound(FourCC),
-    InvalidPresetList,
-    InvalidInstrumentId {
-        preset_id: usize,
-        instrument_id: usize,
-    },
-    InvalidPreset(usize),
-    PresetNotFound,
-    InvalidInstrumentList,
-    InvalidSampleId {
-        instrument_id: usize,
-        sample_id: usize,
-    },
-    InvalidInstrument(usize),
-    InstrumentNotFound,
-    InvalidSampleHeaderList,
-    InvalidZoneList,
-    ZoneNotFound,
-    InvalidGeneratorList,
-    RegionCheckFailed {
-        inst_name: String,
-        region_idx: usize,
-        msg: String,
-    },
-
-    RegionSampleOutOfBounds {
-        inst_name: String,
-        region_idx: usize,
-    },
-}
-
-impl error::Error for SoundFontError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            SoundFontError::IoError(err) => Some(err),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for SoundFontError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            SoundFontError::IoError(err) => Display::fmt(&err, f),
-            SoundFontError::RiffChunkNotFound => write!(f, "the RIFF chunk was not found"),
-            SoundFontError::InvalidRiffChunkType { expected, actual } => write!(
-                f,
-                "the type of the RIFF chunk must be '{expected}', but was '{actual}'",
-            ),
-            SoundFontError::ListChunkNotFound => write!(f, "the LIST chunk was not found"),
-            SoundFontError::InvalidListChunkType { expected, actual } => write!(
-                f,
-                "the type of the LIST chunk must be '{expected}', but was '{actual}'",
-            ),
-            SoundFontError::ListContainsUnknownId(id) => {
-                write!(f, "the INFO list contains an unknown ID '{id}'")
-            }
-            SoundFontError::SampleDataNotFound => write!(f, "no valid sample data was found"),
-            SoundFontError::UnsupportedSampleFormat => write!(f, "SoundFont3 is not yet supported"),
-            SoundFontError::SubChunkNotFound(id) => {
-                write!(f, "the '{id}' sub-chunk was not found")
-            }
-            SoundFontError::InvalidPresetList => write!(f, "the preset list is invalid"),
-            SoundFontError::InvalidInstrumentId {
-                preset_id,
-                instrument_id,
-            } => write!(
-                f,
-                "the preset with the ID '{preset_id}' contains an invalid instrument ID '{instrument_id}'"
-            ),
-            SoundFontError::InvalidPreset(preset_id) => {
-                write!(f, "the preset with the ID '{preset_id}' has no zone")
-            }
-            SoundFontError::PresetNotFound => write!(f, "no valid preset was found"),
-            SoundFontError::InvalidInstrumentList => write!(f, "the instrument list is invalid"),
-            SoundFontError::InvalidSampleId {
-                instrument_id,
-                sample_id,
-            } => write!(
-                f,
-                "the instrument with the ID '{instrument_id}' contains an invalid sample ID '{sample_id}'"
-            ),
-            SoundFontError::InvalidInstrument(instrument_id) => {
-                write!(
-                    f,
-                    "the instrument with the ID '{instrument_id}' has no zone"
-                )
-            }
-            SoundFontError::InstrumentNotFound => write!(f, "no valid instrument was found"),
-            SoundFontError::InvalidSampleHeaderList => {
-                write!(f, "the sample header list is invalid")
-            }
-            SoundFontError::InvalidZoneList => write!(f, "the zone list is invalid"),
-            SoundFontError::ZoneNotFound => write!(f, "no valid zone was found"),
-            SoundFontError::InvalidGeneratorList => write!(f, "the generator list is invalid"),
-            SoundFontError::RegionCheckFailed {
-                inst_name,
-                region_idx,
-                msg,
-            } => {
-                write!(f, "Error at inst {inst_name}, zone {region_idx}: {msg}")
-            }
-            SoundFontError::RegionSampleOutOfBounds {
-                inst_name,
-                region_idx,
-            } => {
-                write!(
-                    f,
-                    "Error at inst {inst_name}, zone {region_idx}: Sample out of bounds"
-                )
-            }
-        }
-    }
-}
-
-impl From<io::Error> for SoundFontError {
-    fn from(err: io::Error) -> Self {
-        SoundFontError::IoError(err)
-    }
-}
-
-/// Reperesents the FourCC.
-/// This is used for error reporting when the binary format is invalid.
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub struct FourCC([u8; 4]);
-
-impl FourCC {
-    pub(crate) const fn from_bytes(mut bytes: [u8; 4]) -> Self {
-        // Replace non-ASCII characters with '?'.
-        bytes[0] = replace_with_question_mark_if_non_ascii(bytes[0]);
-        bytes[1] = replace_with_question_mark_if_non_ascii(bytes[1]);
-        bytes[2] = replace_with_question_mark_if_non_ascii(bytes[2]);
-        bytes[3] = replace_with_question_mark_if_non_ascii(bytes[3]);
-        Self(bytes)
-    }
-
-    pub const fn as_bytes(&self) -> &[u8; 4] {
-        &self.0
-    }
-}
-
-impl Display for FourCC {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        for byte in &self.0 {
-            f.write_char(*byte as char)?;
-        }
-        Ok(())
-    }
-}
-
-impl Debug for FourCC {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        f.write_char('"')?;
-        for byte in &self.0 {
-            f.write_char(*byte as char)?;
-        }
-        f.write_char('"')?;
-        Ok(())
-    }
-}
-
-impl PartialEq<&[u8; 4]> for FourCC {
-    fn eq(&self, other: &&[u8; 4]) -> bool {
-        &self.0 == *other
-    }
-}
-
-impl PartialEq<[u8; 4]> for FourCC {
-    fn eq(&self, other: &[u8; 4]) -> bool {
-        &self.0 == other
-    }
-}
-
-const fn is_ascii_graphic_or_space(byte: u8) -> bool {
-    byte.is_ascii_graphic() || byte == b' '
-}
-
-const fn replace_with_question_mark_if_non_ascii(byte: u8) -> u8 {
-    if is_ascii_graphic_or_space(byte) {
-        byte
-    } else {
-        b'?'
-    }
-}
diff --git a/src/synthesizer/src/soundfont/generator/mod.rs b/src/synthesizer/src/soundfont/generator/mod.rs
deleted file mode 100644
index 5f96a98..0000000
--- a/src/synthesizer/src/soundfont/generator/mod.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-#![allow(dead_code)]
-
-mod r#type;
-pub(crate) use r#type::*;
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-#[derive(Clone, Copy)]
-pub(crate) struct Generator {
-    pub(crate) generator_type: u16,
-    pub(crate) value: u16,
-}
-
-impl Generator {
-    fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let generator_type = BinaryReader::read_u16(reader)?;
-        let value = BinaryReader::read_u16(reader)?;
-
-        Ok(Self {
-            generator_type,
-            value,
-        })
-    }
-
-    pub(crate) fn read_from_chunk<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<Generator>, SoundFontError> {
-        if size % 4 != 0 {
-            return Err(SoundFontError::InvalidGeneratorList);
-        }
-
-        let count = size / 4 - 1;
-
-        let mut generators: Vec<Generator> = Vec::new();
-        for _i in 0..count {
-            generators.push(Generator::new(reader)?);
-        }
-
-        // The last one is the terminator.
-        Generator::new(reader)?;
-
-        Ok(generators)
-    }
-}
diff --git a/src/synthesizer/src/soundfont/generator/type.rs b/src/synthesizer/src/soundfont/generator/type.rs
deleted file mode 100644
index ee75c9d..0000000
--- a/src/synthesizer/src/soundfont/generator/type.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-#![allow(dead_code)]
-
-#[allow(unused)]
-pub(crate) struct GeneratorType {}
-
-#[allow(unused)]
-impl GeneratorType {
-    pub(crate) const START_ADDRESS_OFFSET: u16 = 0;
-    pub(crate) const END_ADDRESS_OFFSET: u16 = 1;
-    pub(crate) const START_LOOP_ADDRESS_OFFSET: u16 = 2;
-    pub(crate) const END_LOOP_ADDRESS_OFFSET: u16 = 3;
-    pub(crate) const START_ADDRESS_COARSE_OFFSET: u16 = 4;
-    pub(crate) const MODULATION_LFO_TO_PITCH: u16 = 5;
-    pub(crate) const VIBRATO_LFO_TO_PITCH: u16 = 6;
-    pub(crate) const MODULATION_ENVELOPE_TO_PITCH: u16 = 7;
-    pub(crate) const INITIAL_FILTER_CUTOFF_FREQUENCY: u16 = 8;
-    pub(crate) const INITIAL_FILTER_Q: u16 = 9;
-    pub(crate) const MODULATION_LFO_TO_FILTER_CUTOFF_FREQUENCY: u16 = 10;
-    pub(crate) const MODULATION_ENVELOPE_TO_FILTER_CUTOFF_FREQUENCY: u16 = 11;
-    pub(crate) const END_ADDRESS_COARSE_OFFSET: u16 = 12;
-    pub(crate) const MODULATION_LFO_TO_VOLUME: u16 = 13;
-    pub(crate) const UNUSED_1: u16 = 14;
-    pub(crate) const CHORUS_EFFECTS_SEND: u16 = 15;
-    pub(crate) const REVERB_EFFECTS_SEND: u16 = 16;
-    pub(crate) const PAN: u16 = 17;
-    pub(crate) const UNUSED_2: u16 = 18;
-    pub(crate) const UNUSED_3: u16 = 19;
-    pub(crate) const UNUSED_4: u16 = 20;
-    pub(crate) const DELAY_MODULATION_LFO: u16 = 21;
-    pub(crate) const FREQUENCY_MODULATION_LFO: u16 = 22;
-    pub(crate) const DELAY_VIBRATO_LFO: u16 = 23;
-    pub(crate) const FREQUENCY_VIBRATO_LFO: u16 = 24;
-    pub(crate) const DELAY_MODULATION_ENVELOPE: u16 = 25;
-    pub(crate) const ATTACK_MODULATION_ENVELOPE: u16 = 26;
-    pub(crate) const HOLD_MODULATION_ENVELOPE: u16 = 27;
-    pub(crate) const DECAY_MODULATION_ENVELOPE: u16 = 28;
-    pub(crate) const SUSTAIN_MODULATION_ENVELOPE: u16 = 29;
-    pub(crate) const RELEASE_MODULATION_ENVELOPE: u16 = 30;
-    pub(crate) const KEY_NUMBER_TO_MODULATION_ENVELOPE_HOLD: u16 = 31;
-    pub(crate) const KEY_NUMBER_TO_MODULATION_ENVELOPE_DECAY: u16 = 32;
-    pub(crate) const DELAY_VOLUME_ENVELOPE: u16 = 33;
-    pub(crate) const ATTACK_VOLUME_ENVELOPE: u16 = 34;
-    pub(crate) const HOLD_VOLUME_ENVELOPE: u16 = 35;
-    pub(crate) const DECAY_VOLUME_ENVELOPE: u16 = 36;
-    pub(crate) const SUSTAIN_VOLUME_ENVELOPE: u16 = 37;
-    pub(crate) const RELEASE_VOLUME_ENVELOPE: u16 = 38;
-    pub(crate) const KEY_NUMBER_TO_VOLUME_ENVELOPE_HOLD: u16 = 39;
-    pub(crate) const KEY_NUMBER_TO_VOLUME_ENVELOPE_DECAY: u16 = 40;
-    pub(crate) const INSTRUMENT: u16 = 41;
-    pub(crate) const RESERVED_1: u16 = 42;
-    pub(crate) const KEY_RANGE: u16 = 43;
-    pub(crate) const VELOCITY_RANGE: u16 = 44;
-    pub(crate) const START_LOOP_ADDRESS_COARSE_OFFSET: u16 = 45;
-    pub(crate) const KEY_NUMBER: u16 = 46;
-    pub(crate) const VELOCITY: u16 = 47;
-    pub(crate) const INITIAL_ATTENUATION: u16 = 48;
-    pub(crate) const RESERVED_2: u16 = 49;
-    pub(crate) const END_LOOP_ADDRESS_COARSE_OFFSET: u16 = 50;
-    pub(crate) const COARSE_TUNE: u16 = 51;
-    pub(crate) const FINE_TUNE: u16 = 52;
-    pub(crate) const SAMPLE_ID: u16 = 53;
-    pub(crate) const SAMPLE_MODES: u16 = 54;
-    pub(crate) const RESERVED_3: u16 = 55;
-    pub(crate) const SCALE_TUNING: u16 = 56;
-    pub(crate) const EXCLUSIVE_CLASS: u16 = 57;
-    pub(crate) const OVERRIDING_ROOT_KEY: u16 = 58;
-    pub(crate) const UNUSED_5: u16 = 59;
-    pub(crate) const UNUSED_END: u16 = 60;
-
-    pub(crate) const COUNT: usize = 61;
-}
diff --git a/src/synthesizer/src/soundfont/info.rs b/src/synthesizer/src/soundfont/info.rs
deleted file mode 100644
index 3cfc37f..0000000
--- a/src/synthesizer/src/soundfont/info.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-/// The information of a SoundFont.
-#[derive(Clone, Debug)]
-pub struct SoundFontInfo {
-    pub(crate) version: SoundFontVersion,
-    pub(crate) target_sound_engine: String,
-    pub(crate) bank_name: String,
-    pub(crate) rom_name: String,
-    pub(crate) rom_version: SoundFontVersion,
-    pub(crate) creation_date: String,
-    pub(crate) author: String,
-    pub(crate) target_product: String,
-    pub(crate) copyright: String,
-    pub(crate) comments: String,
-    pub(crate) tools: String,
-}
-
-impl SoundFontInfo {
-    pub(crate) fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let chunk_id = BinaryReader::read_four_cc(reader)?;
-        if chunk_id != b"LIST" {
-            return Err(SoundFontError::ListChunkNotFound);
-        }
-
-        let end = BinaryReader::read_u32(reader)? as usize;
-        let reader = &mut ReadCounter::new(reader);
-
-        let list_type = BinaryReader::read_four_cc(reader)?;
-        if list_type != b"INFO" {
-            return Err(SoundFontError::InvalidListChunkType {
-                expected: FourCC::from_bytes(*b"INFO"),
-                actual: list_type,
-            });
-        }
-
-        let mut version: Option<SoundFontVersion> = None;
-        let mut target_sound_engine: Option<String> = None;
-        let mut bank_name: Option<String> = None;
-        let mut rom_name: Option<String> = None;
-        let mut rom_version: Option<SoundFontVersion> = None;
-        let mut creation_date: Option<String> = None;
-        let mut author: Option<String> = None;
-        let mut target_product: Option<String> = None;
-        let mut copyright: Option<String> = None;
-        let mut comments: Option<String> = None;
-        let mut tools: Option<String> = None;
-
-        while reader.bytes_read() < end {
-            let id = BinaryReader::read_four_cc(reader)?;
-            let size = BinaryReader::read_u32(reader)? as usize;
-
-            match id.as_bytes() {
-                b"ifil" => version = Some(SoundFontVersion::new(reader)?),
-                b"isng" => {
-                    target_sound_engine =
-                        Some(BinaryReader::read_fixed_length_string(reader, size)?)
-                }
-                b"INAM" => bank_name = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                b"irom" => rom_name = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                b"iver" => rom_version = Some(SoundFontVersion::new(reader)?),
-                b"ICRD" => {
-                    creation_date = Some(BinaryReader::read_fixed_length_string(reader, size)?)
-                }
-                b"IENG" => author = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                b"IPRD" => {
-                    target_product = Some(BinaryReader::read_fixed_length_string(reader, size)?)
-                }
-                b"ICOP" => copyright = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                b"ICMT" => comments = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                b"ISFT" => tools = Some(BinaryReader::read_fixed_length_string(reader, size)?),
-                _ => return Err(SoundFontError::ListContainsUnknownId(id)),
-            }
-        }
-
-        let version = version.unwrap_or_else(SoundFontVersion::default);
-        let target_sound_engine = target_sound_engine.unwrap_or_default();
-        let bank_name = bank_name.unwrap_or_default();
-        let rom_name = rom_name.unwrap_or_default();
-        let rom_version = rom_version.unwrap_or_else(SoundFontVersion::default);
-        let creation_date = creation_date.unwrap_or_default();
-        let author = author.unwrap_or_default();
-        let target_product = target_product.unwrap_or_default();
-        let copyright = copyright.unwrap_or_default();
-        let comments = comments.unwrap_or_default();
-        let tools = tools.unwrap_or_default();
-
-        Ok(Self {
-            version,
-            target_sound_engine,
-            bank_name,
-            rom_name,
-            rom_version,
-            creation_date,
-            author,
-            target_product,
-            copyright,
-            comments,
-            tools,
-        })
-    }
-
-    /// Gets the version of the SoundFont.
-    pub fn get_version(&self) -> &SoundFontVersion {
-        &self.version
-    }
-
-    /// Gets the target sound engine of the SoundFont.
-    pub fn get_target_sound_engine(&self) -> &str {
-        &self.target_sound_engine
-    }
-
-    /// Gets the bank name of the SoundFont.
-    pub fn get_bank_name(&self) -> &str {
-        &self.bank_name
-    }
-
-    /// Gets the ROM name of the SoundFont.
-    pub fn get_rom_name(&self) -> &str {
-        &self.rom_name
-    }
-
-    /// Gets the ROM version of the SoundFont.
-    pub fn get_rom_version(&self) -> &SoundFontVersion {
-        &self.rom_version
-    }
-
-    /// Gets the creation date of the SoundFont.
-    pub fn get_creation_date(&self) -> &str {
-        &self.creation_date
-    }
-
-    /// Gets the auther of the SoundFont.
-    pub fn get_author(&self) -> &str {
-        &self.author
-    }
-
-    /// Gets the target product of the SoundFont.
-    pub fn get_target_product(&self) -> &str {
-        &self.target_product
-    }
-
-    /// Gets the copyright message for the SoundFont.
-    pub fn get_copyright(&self) -> &str {
-        &self.copyright
-    }
-
-    /// Gets the comments for the SoundFont.
-    pub fn get_comments(&self) -> &str {
-        &self.comments
-    }
-
-    /// Gets the tools used to create the SoundFont.
-    pub fn get_tools(&self) -> &str {
-        &self.tools
-    }
-}
diff --git a/src/synthesizer/src/soundfont/instrument/info.rs b/src/synthesizer/src/soundfont/instrument/info.rs
deleted file mode 100644
index 6cac855..0000000
--- a/src/synthesizer/src/soundfont/instrument/info.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-pub(crate) struct InstrumentInfo {
-    pub(crate) name: String,
-    pub(crate) zone_start_index: i32,
-    pub(crate) zone_end_index: i32,
-}
-
-impl InstrumentInfo {
-    fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let name = BinaryReader::read_fixed_length_string(reader, 20)?;
-        let zone_start_index = BinaryReader::read_u16(reader)? as i32;
-
-        Ok(Self {
-            name,
-            zone_start_index,
-            zone_end_index: 0,
-        })
-    }
-
-    pub(crate) fn read_from_chunk<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<InstrumentInfo>, SoundFontError> {
-        if size % 22 != 0 {
-            return Err(SoundFontError::InvalidInstrumentList);
-        }
-
-        let count = size / 22;
-
-        let mut instruments: Vec<InstrumentInfo> = Vec::new();
-        for _i in 0..count {
-            instruments.push(InstrumentInfo::new(reader)?);
-        }
-
-        for i in 0..(count - 1) {
-            instruments[i].zone_end_index = instruments[i + 1].zone_start_index - 1;
-        }
-
-        Ok(instruments)
-    }
-}
diff --git a/src/synthesizer/src/soundfont/instrument/mod.rs b/src/synthesizer/src/soundfont/instrument/mod.rs
deleted file mode 100644
index faf6150..0000000
--- a/src/synthesizer/src/soundfont/instrument/mod.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![allow(dead_code)]
-
-pub(super) mod info;
-
-mod region;
-use info::InstrumentInfo;
-pub use region::*;
-
-use crate::prelude::*;
-
-/// Represents an instrument in the SoundFont.
-#[derive(Clone, Debug)]
-pub struct Instrument {
-    pub(crate) name: String,
-    pub(crate) regions: Vec<InstrumentRegion>,
-}
-
-impl Instrument {
-    fn new(
-        info: &InstrumentInfo,
-        instrument_id: usize,
-        zones: &[Zone],
-        samples: &[SampleHeader],
-    ) -> Result<Self, SoundFontError> {
-        let name = info.name.clone();
-
-        let zone_count = info.zone_end_index - info.zone_start_index + 1;
-        if zone_count <= 0 {
-            return Err(SoundFontError::InvalidInstrument(instrument_id));
-        }
-
-        let span_start = info.zone_start_index as usize;
-        let span_end = span_start + zone_count as usize;
-        let zone_span = &zones[span_start..span_end];
-        let regions = InstrumentRegion::create(instrument_id, zone_span, samples)?;
-
-        Ok(Self { name, regions })
-    }
-
-    pub(crate) fn create(
-        infos: &[InstrumentInfo],
-        zones: &[Zone],
-        samples: &[SampleHeader],
-    ) -> Result<Vec<Instrument>, SoundFontError> {
-        if infos.len() <= 1 {
-            return Err(SoundFontError::InstrumentNotFound);
-        }
-
-        // The last one is the terminator.
-        let count = infos.len() - 1;
-
-        let mut instruments: Vec<Instrument> = Vec::new();
-        for (instrument_id, info) in infos.iter().take(count).enumerate() {
-            instruments.push(Instrument::new(info, instrument_id, zones, samples)?);
-        }
-
-        Ok(instruments)
-    }
-
-    /// Gets the name of the instrument.
-    pub fn get_name(&self) -> &str {
-        &self.name
-    }
-
-    /// Gets the regions of the instrument.
-    pub fn get_regions(&self) -> &[InstrumentRegion] {
-        &self.regions[..]
-    }
-}
diff --git a/src/synthesizer/src/soundfont/instrument/region.rs b/src/synthesizer/src/soundfont/instrument/region.rs
deleted file mode 100644
index d728576..0000000
--- a/src/synthesizer/src/soundfont/instrument/region.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-#![allow(dead_code)]
-
-use generator::GeneratorType;
-
-use crate::{prelude::*, utils};
-
-fn set_parameter(gs: &mut [i16; GeneratorType::COUNT], generator: &Generator) {
-    let index = generator.generator_type as usize;
-
-    // Unknown generators should be ignored.
-    if index < gs.len() {
-        gs[index] = generator.value as i16;
-    }
-}
-
-/// Represents an instrument region.
-/// An instrument region contains all the parameters necessary to synthesize a note.
-#[derive(Clone, Debug)]
-pub struct InstrumentRegion {
-    pub(crate) gs: [i16; GeneratorType::COUNT],
-    pub(crate) sample_start: i32,
-    pub(crate) sample_end: i32,
-    pub(crate) sample_start_loop: i32,
-    pub(crate) sample_end_loop: i32,
-    pub(crate) sample_sample_rate: i32,
-    pub(crate) sample_original_pitch: i32,
-    pub(crate) sample_pitch_correction: i32,
-}
-
-impl InstrumentRegion {
-    fn new(
-        instrument_id: usize,
-        global: &Zone,
-        local: &Zone,
-        samples: &[SampleHeader],
-    ) -> Result<Self, SoundFontError> {
-        let mut gs: [i16; GeneratorType::COUNT] = [0; GeneratorType::COUNT];
-        gs[GeneratorType::INITIAL_FILTER_CUTOFF_FREQUENCY as usize] = 13500;
-        gs[GeneratorType::DELAY_MODULATION_LFO as usize] = -12000;
-        gs[GeneratorType::DELAY_VIBRATO_LFO as usize] = -12000;
-        gs[GeneratorType::DELAY_MODULATION_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::ATTACK_MODULATION_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::HOLD_MODULATION_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::DECAY_MODULATION_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::RELEASE_MODULATION_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::DELAY_VOLUME_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::ATTACK_VOLUME_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::HOLD_VOLUME_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::DECAY_VOLUME_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::RELEASE_VOLUME_ENVELOPE as usize] = -12000;
-        gs[GeneratorType::KEY_RANGE as usize] = 0x7F00;
-        gs[GeneratorType::VELOCITY_RANGE as usize] = 0x7F00;
-        gs[GeneratorType::KEY_NUMBER as usize] = -1;
-        gs[GeneratorType::VELOCITY as usize] = -1;
-        gs[GeneratorType::SCALE_TUNING as usize] = 100;
-        gs[GeneratorType::OVERRIDING_ROOT_KEY as usize] = -1;
-
-        for generator in global.generators.iter() {
-            set_parameter(&mut gs, generator);
-        }
-
-        for generator in local.generators.iter() {
-            set_parameter(&mut gs, generator);
-        }
-
-        let sample_id = gs[GeneratorType::SAMPLE_ID as usize] as usize;
-        if sample_id >= samples.len() {
-            return Err(SoundFontError::InvalidSampleId {
-                instrument_id,
-                sample_id,
-            });
-        }
-        let sample = &samples[sample_id];
-
-        Ok(Self {
-            gs,
-            sample_start: sample.start,
-            sample_end: sample.end,
-            sample_start_loop: sample.start_loop,
-            sample_end_loop: sample.end_loop,
-            sample_sample_rate: sample.sample_rate,
-            sample_original_pitch: sample.original_pitch as i32,
-            sample_pitch_correction: sample.pitch_correction as i32,
-        })
-    }
-
-    pub(crate) fn create(
-        instrument_id: usize,
-        zones: &[Zone],
-        samples: &[SampleHeader],
-    ) -> Result<Vec<InstrumentRegion>, SoundFontError> {
-        // Is the first one the global zone?
-        if zones[0].generators.is_empty()
-            || zones[0].generators.last().unwrap().generator_type != GeneratorType::SAMPLE_ID
-        {
-            // The first one is the global zone.
-            let global = &zones[0];
-
-            // The global zone is regarded as the base setting of subsequent zones.
-            let count = zones.len() - 1;
-            let mut regions: Vec<InstrumentRegion> = Vec::new();
-            for i in 0..count {
-                regions.push(InstrumentRegion::new(
-                    instrument_id,
-                    global,
-                    &zones[i + 1],
-                    samples,
-                )?);
-            }
-
-            Ok(regions)
-        } else {
-            // No global zone.
-            let count = zones.len();
-            let mut regions: Vec<InstrumentRegion> = Vec::new();
-            for zone in zones.iter().take(count) {
-                regions.push(InstrumentRegion::new(
-                    instrument_id,
-                    &Zone::empty(),
-                    zone,
-                    samples,
-                )?);
-            }
-
-            Ok(regions)
-        }
-    }
-
-    /// Checks if the region covers the given key and velocity.
-    /// Returns `true` if the region covers the given key and velocity.
-    ///
-    /// # Arguments
-    ///
-    /// * `key` - The key of a note.
-    /// * `velocity` - The velocity of a note.
-    pub fn contains(&self, key: u8, velocity: u8) -> bool {
-        let contains_key = self.get_key_range_start() <= key && key <= self.get_key_range_end();
-        let contains_velocity = self.get_velocity_range_start() <= velocity
-            && velocity <= self.get_velocity_range_end();
-        contains_key && contains_velocity
-    }
-
-    pub fn get_sample_start(&self) -> i32 {
-        self.sample_start + self.get_start_address_offset()
-    }
-
-    pub fn get_sample_end(&self) -> i32 {
-        self.sample_end + self.get_end_address_offset()
-    }
-
-    pub fn get_sample_start_loop(&self) -> i32 {
-        self.sample_start_loop + self.get_start_loop_address_offset()
-    }
-
-    pub fn get_sample_end_loop(&self) -> i32 {
-        self.sample_end_loop + self.get_end_loop_address_offset()
-    }
-
-    pub fn get_start_address_offset(&self) -> i32 {
-        32768 * self.gs[GeneratorType::START_ADDRESS_COARSE_OFFSET as usize] as i32
-            + self.gs[GeneratorType::START_ADDRESS_OFFSET as usize] as i32
-    }
-
-    pub fn get_end_address_offset(&self) -> i32 {
-        32768 * self.gs[GeneratorType::END_ADDRESS_COARSE_OFFSET as usize] as i32
-            + self.gs[GeneratorType::END_ADDRESS_OFFSET as usize] as i32
-    }
-
-    pub fn get_start_loop_address_offset(&self) -> i32 {
-        32768 * self.gs[GeneratorType::START_LOOP_ADDRESS_COARSE_OFFSET as usize] as i32
-            + self.gs[GeneratorType::START_LOOP_ADDRESS_OFFSET as usize] as i32
-    }
-
-    pub fn get_end_loop_address_offset(&self) -> i32 {
-        32768 * self.gs[GeneratorType::END_LOOP_ADDRESS_COARSE_OFFSET as usize] as i32
-            + self.gs[GeneratorType::END_LOOP_ADDRESS_OFFSET as usize] as i32
-    }
-
-    pub fn get_modulation_lfo_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_LFO_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_vibrato_lfo_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::VIBRATO_LFO_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_modulation_envelope_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_ENVELOPE_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_initial_filter_cutoff_frequency(&self) -> f32 {
-        utils::cents_to_hertz(
-            self.gs[GeneratorType::INITIAL_FILTER_CUTOFF_FREQUENCY as usize] as f32,
-        )
-    }
-
-    pub fn get_initial_filter_q(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::INITIAL_FILTER_Q as usize] as f32
-    }
-
-    pub fn get_modulation_lfo_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_LFO_TO_FILTER_CUTOFF_FREQUENCY as usize] as i32
-    }
-
-    pub fn get_modulation_envelope_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_ENVELOPE_TO_FILTER_CUTOFF_FREQUENCY as usize] as i32
-    }
-
-    pub fn get_modulation_lfo_to_volume(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::MODULATION_LFO_TO_VOLUME as usize] as f32
-    }
-
-    pub fn get_chorus_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::CHORUS_EFFECTS_SEND as usize] as f32
-    }
-
-    pub fn get_reverb_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::REVERB_EFFECTS_SEND as usize] as f32
-    }
-
-    pub fn get_pan(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::PAN as usize] as f32
-    }
-
-    pub fn get_delay_modulation_lfo(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::DELAY_MODULATION_LFO as usize] as f32)
-    }
-
-    pub fn get_frequency_modulation_lfo(&self) -> f32 {
-        utils::cents_to_hertz(self.gs[GeneratorType::FREQUENCY_MODULATION_LFO as usize] as f32)
-    }
-
-    pub fn get_delay_vibrato_lfo(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::DELAY_VIBRATO_LFO as usize] as f32)
-    }
-
-    pub fn get_frequency_vibrato_lfo(&self) -> f32 {
-        utils::cents_to_hertz(self.gs[GeneratorType::FREQUENCY_VIBRATO_LFO as usize] as f32)
-    }
-
-    pub fn get_delay_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs[GeneratorType::DELAY_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_attack_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs[GeneratorType::ATTACK_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_hold_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs[GeneratorType::HOLD_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_decay_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs[GeneratorType::DECAY_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_sustain_modulation_envelope(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::SUSTAIN_MODULATION_ENVELOPE as usize] as f32
-    }
-
-    pub fn get_release_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs[GeneratorType::RELEASE_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_key_number_to_modulation_envelope_hold(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_HOLD as usize] as i32
-    }
-
-    pub fn get_key_number_to_modulation_envelope_decay(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_DECAY as usize] as i32
-    }
-
-    pub fn get_delay_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::DELAY_VOLUME_ENVELOPE as usize] as f32)
-    }
-
-    pub fn get_attack_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::ATTACK_VOLUME_ENVELOPE as usize] as f32)
-    }
-
-    pub fn get_hold_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::HOLD_VOLUME_ENVELOPE as usize] as f32)
-    }
-
-    pub fn get_decay_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::DECAY_VOLUME_ENVELOPE as usize] as f32)
-    }
-
-    pub fn get_sustain_volume_envelope(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::SUSTAIN_VOLUME_ENVELOPE as usize] as f32
-    }
-
-    pub fn get_release_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs[GeneratorType::RELEASE_VOLUME_ENVELOPE as usize] as f32)
-    }
-
-    pub fn get_key_number_to_volume_envelope_hold(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_HOLD as usize] as i32
-    }
-
-    pub fn get_key_number_to_volume_envelope_decay(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_DECAY as usize] as i32
-    }
-
-    pub fn get_key_range_start(&self) -> u8 {
-        (self.gs[GeneratorType::KEY_RANGE as usize] & 0xFF) as u8
-    }
-
-    pub fn get_key_range_end(&self) -> u8 {
-        ((self.gs[GeneratorType::KEY_RANGE as usize] >> 8) & 0xFF) as u8
-    }
-
-    pub fn get_velocity_range_start(&self) -> u8 {
-        (self.gs[GeneratorType::VELOCITY_RANGE as usize] & 0xFF) as u8
-    }
-
-    pub fn get_velocity_range_end(&self) -> u8 {
-        ((self.gs[GeneratorType::VELOCITY_RANGE as usize] >> 8) & 0xFF) as u8
-    }
-
-    pub fn get_initial_attenuation(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::INITIAL_ATTENUATION as usize] as f32
-    }
-
-    pub fn get_coarse_tune(&self) -> i32 {
-        self.gs[GeneratorType::COARSE_TUNE as usize] as i32
-    }
-
-    pub fn get_fine_tune(&self) -> i32 {
-        self.gs[GeneratorType::FINE_TUNE as usize] as i32 + self.sample_pitch_correction
-    }
-
-    pub fn get_sample_modes(&self) -> LoopMode {
-        LoopMode::from_i16(self.gs[GeneratorType::SAMPLE_MODES as usize])
-    }
-
-    pub fn get_scale_tuning(&self) -> i32 {
-        self.gs[GeneratorType::SCALE_TUNING as usize] as i32
-    }
-
-    pub fn get_exclusive_class(&self) -> i32 {
-        self.gs[GeneratorType::EXCLUSIVE_CLASS as usize] as i32
-    }
-
-    pub fn get_root_key(&self) -> i32 {
-        if self.gs[GeneratorType::OVERRIDING_ROOT_KEY as usize] != -1 {
-            self.gs[GeneratorType::OVERRIDING_ROOT_KEY as usize] as i32
-        } else {
-            self.sample_original_pitch
-        }
-    }
-
-    pub fn get_sample_id(&self) -> usize {
-        self.gs[GeneratorType::SAMPLE_ID as usize] as usize
-    }
-}
diff --git a/src/synthesizer/src/soundfont/mod.rs b/src/synthesizer/src/soundfont/mod.rs
deleted file mode 100644
index af37875..0000000
--- a/src/synthesizer/src/soundfont/mod.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-#![allow(dead_code)]
-
-use bevy_platform::prelude::*;
-use tracing::error;
-
-pub mod generator;
-pub mod instrument;
-pub mod preset;
-pub mod zone;
-
-mod info;
-pub use info::*;
-mod parameters;
-mod sampledata;
-use parameters::SoundFontParameters;
-pub use sampledata::*;
-mod version;
-pub use version::*;
-mod error;
-pub use error::*;
-mod sample_header;
-pub use sample_header::*;
-
-use crate::prelude::*;
-
-/// Reperesents a SoundFont.
-#[derive(Clone, Debug)]
-pub struct SoundFont {
-    pub(crate) info: SoundFontInfo,
-    pub(crate) bits_per_sample: i32,
-    pub(crate) wave_data: Arc<Vec<i16>>,
-    pub(crate) sample_headers: Vec<SampleHeader>,
-    pub(crate) presets: Vec<Preset>,
-    pub(crate) instruments: Vec<Instrument>,
-}
-
-impl SoundFont {
-    /// Loads a SoundFont from the stream.
-    ///
-    /// # Arguments
-    ///
-    /// * `reader` - The data stream used to load the SoundFont.
-    pub fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let chunk_id = BinaryReader::read_four_cc(reader)?;
-        if chunk_id != b"RIFF" {
-            return Err(SoundFontError::RiffChunkNotFound);
-        }
-
-        let _size = BinaryReader::read_i32(reader);
-
-        let form_type = BinaryReader::read_four_cc(reader)?;
-        if form_type != b"sfbk" {
-            return Err(SoundFontError::InvalidRiffChunkType {
-                expected: FourCC::from_bytes(*b"sfbk"),
-                actual: form_type,
-            });
-        }
-
-        let info = SoundFontInfo::new(reader)?;
-        let sample_data = SoundFontSampleData::new(reader)?;
-        let parameters = SoundFontParameters::new(reader)?;
-
-        let sound_font = Self {
-            info,
-            bits_per_sample: 16,
-            wave_data: Arc::new(sample_data.wave_data),
-            sample_headers: parameters.sample_headers,
-            presets: parameters.presets,
-            instruments: parameters.instruments,
-        };
-
-        if let Err(e) = sound_font.sanity_check() {
-            error!("Sanity Check Failed: {e}");
-        };
-
-        Ok(sound_font)
-    }
-
-    fn sanity_check(&self) -> Result<(), SoundFontError> {
-        // https://github.com/sinshu/rustysynth/issues/22
-        // https://github.com/sinshu/rustysynth/issues/33
-        for (inst_idx, instrument) in self.instruments.iter().enumerate() {
-            for (region_idx, region) in instrument.regions.iter().enumerate() {
-                let inst_name = format!("{inst_idx} {:?}", instrument.get_name());
-
-                let start = region.get_sample_start();
-                let end = region.get_sample_end();
-                let start_loop = region.get_sample_start_loop();
-                let end_loop = region.get_sample_end_loop();
-
-                if start < 0
-                    || start_loop < 0
-                    || end as usize >= self.wave_data.len()
-                    || end_loop as usize >= self.wave_data.len()
-                {
-                    return Err(SoundFontError::RegionSampleOutOfBounds {
-                        inst_name,
-                        region_idx,
-                    });
-                }
-                if end <= start {
-                    return Err(SoundFontError::RegionCheckFailed {
-                        inst_name,
-                        region_idx,
-                        msg: "end < start".into(),
-                    });
-                }
-                if end_loop < start_loop {
-                    return Err(SoundFontError::RegionCheckFailed {
-                        inst_name,
-                        region_idx,
-                        msg: "end_loop < start_loop".into(),
-                    });
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Gets the information of the SoundFont.
-    pub fn get_info(&self) -> &SoundFontInfo {
-        &self.info
-    }
-
-    /// Gets the bits per sample of the sample data.
-    pub fn get_bits_per_sample(&self) -> i32 {
-        self.bits_per_sample
-    }
-
-    /// Gets the sample data.
-    pub fn get_wave_data(&self) -> &[i16] {
-        &self.wave_data[..]
-    }
-
-    /// Gets the samples of the SoundFont.
-    pub fn get_sample_headers(&self) -> &[SampleHeader] {
-        &self.sample_headers[..]
-    }
-
-    /// Gets the presets of the SoundFont.
-    pub fn get_presets(&self) -> &[Preset] {
-        &self.presets[..]
-    }
-
-    /// Gets the instruments of the SoundFont.
-    pub fn get_instruments(&self) -> &[Instrument] {
-        &self.instruments[..]
-    }
-}
diff --git a/src/synthesizer/src/soundfont/parameters.rs b/src/synthesizer/src/soundfont/parameters.rs
deleted file mode 100644
index e301699..0000000
--- a/src/synthesizer/src/soundfont/parameters.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-#![allow(dead_code)]
-
-use bevy_platform::prelude::*;
-use instrument::info::InstrumentInfo;
-use preset::info::PresetInfo;
-use zone::ZoneInfo;
-
-use crate::prelude::*;
-
-pub(crate) struct SoundFontParameters {
-    pub(crate) sample_headers: Vec<SampleHeader>,
-    pub(crate) presets: Vec<Preset>,
-    pub(crate) instruments: Vec<Instrument>,
-}
-
-impl SoundFontParameters {
-    pub(crate) fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let chunk_id = BinaryReader::read_four_cc(reader)?;
-        if chunk_id != b"LIST" {
-            return Err(SoundFontError::ListChunkNotFound);
-        }
-
-        let end = BinaryReader::read_u32(reader)? as usize;
-        let reader = &mut ReadCounter::new(reader);
-
-        let list_type = BinaryReader::read_four_cc(reader)?;
-        if list_type != b"pdta" {
-            return Err(SoundFontError::InvalidListChunkType {
-                expected: FourCC::from_bytes(*b"pdta"),
-                actual: list_type,
-            });
-        }
-
-        let mut preset_infos: Option<Vec<PresetInfo>> = None;
-        let mut preset_bag: Option<Vec<ZoneInfo>> = None;
-        let mut preset_generators: Option<Vec<Generator>> = None;
-        let mut instrument_infos: Option<Vec<InstrumentInfo>> = None;
-        let mut instrument_bag: Option<Vec<ZoneInfo>> = None;
-        let mut instrument_generators: Option<Vec<Generator>> = None;
-        let mut sample_headers: Option<Vec<SampleHeader>> = None;
-
-        while reader.bytes_read() < end {
-            let id = BinaryReader::read_four_cc(reader)?;
-            let size = BinaryReader::read_u32(reader)? as usize;
-
-            match id.as_bytes() {
-                b"phdr" => preset_infos = Some(PresetInfo::read_from_chunk(reader, size)?),
-                b"pbag" => preset_bag = Some(ZoneInfo::read_from_chunk(reader, size)?),
-                b"pmod" => BinaryReader::discard_data(reader, size)?,
-                b"pgen" => preset_generators = Some(Generator::read_from_chunk(reader, size)?),
-                b"inst" => instrument_infos = Some(InstrumentInfo::read_from_chunk(reader, size)?),
-                b"ibag" => instrument_bag = Some(ZoneInfo::read_from_chunk(reader, size)?),
-                b"imod" => BinaryReader::discard_data(reader, size)?,
-                b"igen" => instrument_generators = Some(Generator::read_from_chunk(reader, size)?),
-                b"shdr" => sample_headers = Some(SampleHeader::read_from_chunk(reader, size)?),
-                _ => return Err(SoundFontError::ListContainsUnknownId(id)),
-            }
-        }
-
-        let preset_infos = preset_infos.ok_or(SoundFontError::SubChunkNotFound(
-            FourCC::from_bytes(*b"PHDR"),
-        ))?;
-
-        let preset_bag = preset_bag.ok_or(SoundFontError::SubChunkNotFound(FourCC::from_bytes(
-            *b"PBAG",
-        )))?;
-
-        let preset_generators = preset_generators.ok_or(SoundFontError::SubChunkNotFound(
-            FourCC::from_bytes(*b"PGEN"),
-        ))?;
-
-        let instrument_infos = instrument_infos.ok_or(SoundFontError::SubChunkNotFound(
-            FourCC::from_bytes(*b"INST"),
-        ))?;
-
-        let instrument_bag = instrument_bag.ok_or(SoundFontError::SubChunkNotFound(
-            FourCC::from_bytes(*b"IBAG"),
-        ))?;
-
-        let instrument_generators = instrument_generators.ok_or(
-            SoundFontError::SubChunkNotFound(FourCC::from_bytes(*b"IGEN")),
-        )?;
-
-        let sample_headers = sample_headers.ok_or(SoundFontError::SubChunkNotFound(
-            FourCC::from_bytes(*b"SHDR"),
-        ))?;
-
-        let instrument_zones = Zone::create(&instrument_bag, &instrument_generators)?;
-        let instruments =
-            Instrument::create(&instrument_infos, &instrument_zones, &sample_headers)?;
-
-        let preset_zones = Zone::create(&preset_bag, &preset_generators)?;
-        let presets = Preset::create(&preset_infos, &preset_zones, &instruments)?;
-
-        Ok(Self {
-            sample_headers,
-            presets,
-            instruments,
-        })
-    }
-}
diff --git a/src/synthesizer/src/soundfont/preset/info.rs b/src/synthesizer/src/soundfont/preset/info.rs
deleted file mode 100644
index 79d8f50..0000000
--- a/src/synthesizer/src/soundfont/preset/info.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-pub(crate) struct PresetInfo {
-    pub(crate) name: String,
-    pub(crate) patch_number: i32,
-    pub(crate) bank_number: i32,
-    pub(crate) zone_start_index: i32,
-    pub(crate) zone_end_index: i32,
-    pub(crate) library: i32,
-    pub(crate) genre: i32,
-    pub(crate) morphology: i32,
-}
-
-impl PresetInfo {
-    fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let name = BinaryReader::read_fixed_length_string(reader, 20)?;
-        let patch_number = BinaryReader::read_u16(reader)? as i32;
-        let bank_number = BinaryReader::read_u16(reader)? as i32;
-        let zone_start_index = BinaryReader::read_u16(reader)? as i32;
-        let library = BinaryReader::read_i32(reader)?;
-        let genre = BinaryReader::read_i32(reader)?;
-        let morphology = BinaryReader::read_i32(reader)?;
-
-        Ok(Self {
-            name,
-            patch_number,
-            bank_number,
-            zone_start_index,
-            zone_end_index: 0,
-            library,
-            genre,
-            morphology,
-        })
-    }
-
-    pub(crate) fn read_from_chunk<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<PresetInfo>, SoundFontError> {
-        if size % 38 != 0 {
-            return Err(SoundFontError::InvalidPresetList);
-        }
-
-        let count = size / 38;
-
-        let mut presets: Vec<PresetInfo> = Vec::new();
-        for _i in 0..count {
-            presets.push(PresetInfo::new(reader)?);
-        }
-
-        for i in 0..(count - 1) {
-            presets[i].zone_end_index = presets[i + 1].zone_start_index - 1;
-        }
-
-        Ok(presets)
-    }
-}
diff --git a/src/synthesizer/src/soundfont/preset/mod.rs b/src/synthesizer/src/soundfont/preset/mod.rs
deleted file mode 100644
index c001b77..0000000
--- a/src/synthesizer/src/soundfont/preset/mod.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-#![allow(dead_code)]
-
-pub(super) mod info;
-
-mod region;
-use info::PresetInfo;
-pub use region::*;
-
-use crate::prelude::*;
-
-/// Represents a preset in the SoundFont.
-#[derive(Clone, Debug)]
-pub struct Preset {
-    pub(crate) name: String,
-    pub(crate) patch_number: i32,
-    pub(crate) bank_number: i32,
-    pub(crate) library: i32,
-    pub(crate) genre: i32,
-    pub(crate) morphology: i32,
-    pub(crate) regions: Vec<PresetRegion>,
-}
-
-impl Preset {
-    fn new(
-        info: &PresetInfo,
-        preset_id: usize,
-        zones: &[Zone],
-        instruments: &[Instrument],
-    ) -> Result<Self, SoundFontError> {
-        let name = info.name.clone();
-
-        let zone_count = info.zone_end_index - info.zone_start_index + 1;
-        if zone_count <= 0 {
-            return Err(SoundFontError::InvalidPreset(preset_id));
-        }
-
-        let span_start = info.zone_start_index as usize;
-        let span_end = span_start + zone_count as usize;
-        let zone_span = &zones[span_start..span_end];
-        let regions = PresetRegion::create(preset_id, zone_span, instruments)?;
-
-        Ok(Self {
-            name,
-            patch_number: info.patch_number,
-            bank_number: info.bank_number,
-            library: info.library,
-            genre: info.genre,
-            morphology: info.morphology,
-            regions,
-        })
-    }
-
-    pub(crate) fn create(
-        infos: &[PresetInfo],
-        zones: &[Zone],
-        instruments: &[Instrument],
-    ) -> Result<Vec<Preset>, SoundFontError> {
-        if infos.len() <= 1 {
-            return Err(SoundFontError::PresetNotFound);
-        }
-
-        // The last one is the terminator.
-        let count = infos.len() - 1;
-
-        let mut presets: Vec<Preset> = Vec::new();
-        for (preset_id, info) in infos.iter().take(count).enumerate() {
-            presets.push(Preset::new(info, preset_id, zones, instruments)?);
-        }
-
-        Ok(presets)
-    }
-
-    /// Gets the name of the preset.
-    pub fn get_name(&self) -> &str {
-        &self.name
-    }
-
-    /// Gets the patch number of the preset.
-    pub fn get_patch_number(&self) -> i32 {
-        self.patch_number
-    }
-
-    /// Gets the bank number of the preset.
-    pub fn get_bank_number(&self) -> i32 {
-        self.bank_number
-    }
-
-    /// Gets the library info.
-    pub fn get_library(&self) -> i32 {
-        self.library
-    }
-
-    /// Gets the genre info.
-    pub fn get_genre(&self) -> i32 {
-        self.genre
-    }
-
-    /// Gets the morphology info.
-    pub fn get_morphology(&self) -> i32 {
-        self.morphology
-    }
-
-    /// Gets the regions of the preset.
-    pub fn get_regions(&self) -> &[PresetRegion] {
-        &self.regions[..]
-    }
-}
diff --git a/src/synthesizer/src/soundfont/preset/region.rs b/src/synthesizer/src/soundfont/preset/region.rs
deleted file mode 100644
index 4b8a2b4..0000000
--- a/src/synthesizer/src/soundfont/preset/region.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-#![allow(dead_code)]
-
-use generator::GeneratorType;
-
-use crate::{prelude::*, utils};
-
-fn set_parameter(gs: &mut [i16; GeneratorType::COUNT], generator: &Generator) {
-    let index = generator.generator_type as usize;
-
-    // Unknown generators should be ignored.
-    if index < gs.len() {
-        gs[index] = generator.value as i16;
-    }
-}
-
-/// Represents a preset region.
-/// A preset region indicates how the parameters of the instrument should be modified in the preset.
-#[derive(Clone, Debug)]
-pub struct PresetRegion {
-    pub(crate) gs: [i16; GeneratorType::COUNT],
-    pub(crate) instrument: usize,
-}
-
-impl PresetRegion {
-    fn new(
-        preset_id: usize,
-        global: &Zone,
-        local: &Zone,
-        samples: &[Instrument],
-    ) -> Result<Self, SoundFontError> {
-        let mut gs: [i16; GeneratorType::COUNT] = [0; GeneratorType::COUNT];
-        gs[GeneratorType::KEY_RANGE as usize] = 0x7F00;
-        gs[GeneratorType::VELOCITY_RANGE as usize] = 0x7F00;
-
-        for generator in global.generators.iter() {
-            set_parameter(&mut gs, generator);
-        }
-
-        for generator in local.generators.iter() {
-            set_parameter(&mut gs, generator);
-        }
-
-        let instrument_id = gs[GeneratorType::INSTRUMENT as usize] as usize;
-        if instrument_id >= samples.len() {
-            return Err(SoundFontError::InvalidInstrumentId {
-                preset_id,
-                instrument_id,
-            });
-        }
-
-        Ok(Self {
-            gs,
-            instrument: instrument_id,
-        })
-    }
-
-    pub(crate) fn create(
-        preset_id: usize,
-        zones: &[Zone],
-        instruments: &[Instrument],
-    ) -> Result<Vec<PresetRegion>, SoundFontError> {
-        // Is the first one the global zone?
-        if zones[0].generators.is_empty()
-            || zones[0].generators.last().unwrap().generator_type != GeneratorType::INSTRUMENT
-        {
-            // The first one is the global zone.
-            let global = &zones[0];
-
-            // The global zone is regarded as the base setting of subsequent zones.
-            let count = zones.len() - 1;
-            let mut regions: Vec<PresetRegion> = Vec::new();
-            for i in 0..count {
-                regions.push(PresetRegion::new(
-                    preset_id,
-                    global,
-                    &zones[i + 1],
-                    instruments,
-                )?);
-            }
-
-            Ok(regions)
-        } else {
-            // No global zone.
-            let count = zones.len();
-            let mut regions: Vec<PresetRegion> = Vec::new();
-            for zone in zones.iter().take(count) {
-                regions.push(PresetRegion::new(
-                    preset_id,
-                    &Zone::empty(),
-                    zone,
-                    instruments,
-                )?);
-            }
-
-            Ok(regions)
-        }
-    }
-
-    /// Checks if the region covers the given key and velocity.
-    /// Returns `true` if the region covers the given key and velocity.
-    ///
-    /// # Arguments
-    ///
-    /// * `key` - The key of a note.
-    /// * `velocity` - The velocity of a note.
-    pub fn contains(&self, key: u8, velocity: u8) -> bool {
-        let contains_key = self.get_key_range_start() <= key && key <= self.get_key_range_end();
-        let contains_velocity = self.get_velocity_range_start() <= velocity
-            && velocity <= self.get_velocity_range_end();
-        contains_key && contains_velocity
-    }
-
-    pub fn get_modulation_lfo_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_LFO_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_vibrato_lfo_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::VIBRATO_LFO_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_modulation_envelope_to_pitch(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_ENVELOPE_TO_PITCH as usize] as i32
-    }
-
-    pub fn get_initial_filter_cutoff_frequency(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::INITIAL_FILTER_CUTOFF_FREQUENCY as usize] as f32,
-        )
-    }
-
-    pub fn get_initial_filter_q(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::INITIAL_FILTER_Q as usize] as f32
-    }
-
-    pub fn get_modulation_lfo_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_LFO_TO_FILTER_CUTOFF_FREQUENCY as usize] as i32
-    }
-
-    pub fn get_modulation_envelope_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs[GeneratorType::MODULATION_ENVELOPE_TO_FILTER_CUTOFF_FREQUENCY as usize] as i32
-    }
-
-    pub fn get_modulation_lfo_to_volume(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::MODULATION_LFO_TO_VOLUME as usize] as f32
-    }
-
-    pub fn get_chorus_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::CHORUS_EFFECTS_SEND as usize] as f32
-    }
-
-    pub fn get_reverb_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::REVERB_EFFECTS_SEND as usize] as f32
-    }
-
-    pub fn get_pan(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::PAN as usize] as f32
-    }
-
-    pub fn get_delay_modulation_lfo(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DELAY_MODULATION_LFO as usize] as f32,
-        )
-    }
-
-    pub fn get_frequency_modulation_lfo(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::FREQUENCY_MODULATION_LFO as usize] as f32,
-        )
-    }
-
-    pub fn get_delay_vibrato_lfo(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DELAY_VIBRATO_LFO as usize] as f32,
-        )
-    }
-
-    pub fn get_frequency_vibrato_lfo(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::FREQUENCY_VIBRATO_LFO as usize] as f32,
-        )
-    }
-
-    pub fn get_delay_modulation_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DELAY_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_attack_modulation_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::ATTACK_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_hold_modulation_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::HOLD_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_decay_modulation_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DECAY_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_sustain_modulation_envelope(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::SUSTAIN_MODULATION_ENVELOPE as usize] as f32
-    }
-
-    pub fn get_release_modulation_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::RELEASE_MODULATION_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_key_number_to_modulation_envelope_hold(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_HOLD as usize] as i32
-    }
-
-    pub fn get_key_number_to_modulation_envelope_decay(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_DECAY as usize] as i32
-    }
-
-    pub fn get_delay_volume_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DELAY_VOLUME_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_attack_volume_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::ATTACK_VOLUME_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_hold_volume_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::HOLD_VOLUME_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_decay_volume_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::DECAY_VOLUME_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_sustain_volume_envelope(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::SUSTAIN_VOLUME_ENVELOPE as usize] as f32
-    }
-
-    pub fn get_release_volume_envelope(&self) -> f32 {
-        utils::cents_to_multiplying_factor(
-            self.gs[GeneratorType::RELEASE_VOLUME_ENVELOPE as usize] as f32,
-        )
-    }
-
-    pub fn get_key_number_to_volume_envelope_hold(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_HOLD as usize] as i32
-    }
-
-    pub fn get_key_number_to_volume_envelope_decay(&self) -> i32 {
-        self.gs[GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_DECAY as usize] as i32
-    }
-
-    pub fn get_key_range_start(&self) -> u8 {
-        (self.gs[GeneratorType::KEY_RANGE as usize] & 0xFF) as u8
-    }
-
-    pub fn get_key_range_end(&self) -> u8 {
-        ((self.gs[GeneratorType::KEY_RANGE as usize] >> 8) & 0xFF) as u8
-    }
-
-    pub fn get_velocity_range_start(&self) -> u8 {
-        (self.gs[GeneratorType::VELOCITY_RANGE as usize] & 0xFF) as u8
-    }
-
-    pub fn get_velocity_range_end(&self) -> u8 {
-        ((self.gs[GeneratorType::VELOCITY_RANGE as usize] >> 8) & 0xFF) as u8
-    }
-
-    pub fn get_initial_attenuation(&self) -> f32 {
-        0.1_f32 * self.gs[GeneratorType::INITIAL_ATTENUATION as usize] as f32
-    }
-
-    pub fn get_coarse_tune(&self) -> i32 {
-        self.gs[GeneratorType::COARSE_TUNE as usize] as i32
-    }
-
-    pub fn get_fine_tune(&self) -> i32 {
-        self.gs[GeneratorType::FINE_TUNE as usize] as i32
-    }
-
-    pub fn get_scale_tuning(&self) -> i32 {
-        self.gs[GeneratorType::SCALE_TUNING as usize] as i32
-    }
-
-    pub fn get_instrument_id(&self) -> usize {
-        self.instrument
-    }
-}
diff --git a/src/synthesizer/src/soundfont/sample_header.rs b/src/synthesizer/src/soundfont/sample_header.rs
deleted file mode 100644
index 22a002a..0000000
--- a/src/synthesizer/src/soundfont/sample_header.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-/// Represents a sample in the SoundFont.
-#[derive(Clone, Debug)]
-pub struct SampleHeader {
-    pub(crate) name: String,
-    pub(crate) start: i32,
-    pub(crate) end: i32,
-    pub(crate) start_loop: i32,
-    pub(crate) end_loop: i32,
-    pub(crate) sample_rate: i32,
-    pub(crate) original_pitch: u8,
-    pub(crate) pitch_correction: i8,
-    pub(crate) link: u16,
-    pub(crate) sample_type: u16,
-}
-
-impl SampleHeader {
-    fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let name = BinaryReader::read_fixed_length_string(reader, 20)?;
-        let start = BinaryReader::read_i32(reader)?;
-        let end = BinaryReader::read_i32(reader)?;
-        let start_loop = BinaryReader::read_i32(reader)?;
-        let end_loop = BinaryReader::read_i32(reader)?;
-        let sample_rate = BinaryReader::read_i32(reader)?;
-        let original_pitch = BinaryReader::read_u8(reader)?;
-        let pitch_correction = BinaryReader::read_i8(reader)?;
-        let link = BinaryReader::read_u16(reader)?;
-        let sample_type = BinaryReader::read_u16(reader)?;
-
-        Ok(Self {
-            name,
-            start,
-            end,
-            start_loop,
-            end_loop,
-            sample_rate,
-            original_pitch,
-            pitch_correction,
-            link,
-            sample_type,
-        })
-    }
-
-    pub(crate) fn read_from_chunk<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<SampleHeader>, SoundFontError> {
-        if size % 46 != 0 {
-            return Err(SoundFontError::InvalidSampleHeaderList);
-        }
-
-        let count = size / 46 - 1;
-
-        let mut headers: Vec<SampleHeader> = Vec::new();
-        for _i in 0..count {
-            headers.push(SampleHeader::new(reader)?);
-        }
-
-        // The last one is the terminator.
-        SampleHeader::new(reader)?;
-
-        Ok(headers)
-    }
-
-    /// Gets the name of the sample.
-    pub fn get_name(&self) -> &str {
-        &self.name
-    }
-
-    /// Gets the start point of the sample in the sample data.
-    pub fn get_start(&self) -> i32 {
-        self.start
-    }
-
-    /// Gets the end point of the sample in the sample data.
-    pub fn get_end(&self) -> i32 {
-        self.end
-    }
-
-    /// Gets the loop start point of the sample in the sample data.
-    pub fn get_start_loop(&self) -> i32 {
-        self.start_loop
-    }
-
-    /// Gets the loop end point of the sample in the sample data.
-    pub fn get_end_loop(&self) -> i32 {
-        self.end_loop
-    }
-
-    /// Gets the sample rate of the sample.
-    pub fn get_sample_rate(&self) -> i32 {
-        self.sample_rate
-    }
-
-    /// Gets the key number of the recorded pitch of the sample.
-    pub fn get_original_pitch(&self) -> i32 {
-        self.original_pitch as i32
-    }
-
-    /// Gets the pitch correction in cents that should be applied to the sample on playback.
-    pub fn get_pitch_correction(&self) -> i32 {
-        self.pitch_correction as i32
-    }
-
-    /// Gets the link info.
-    pub fn get_link(&self) -> i32 {
-        self.link as i32
-    }
-
-    /// Gets the sample type.
-    pub fn get_sample_type(&self) -> i32 {
-        self.sample_type as i32
-    }
-}
diff --git a/src/synthesizer/src/soundfont/sampledata.rs b/src/synthesizer/src/soundfont/sampledata.rs
deleted file mode 100644
index a0e7d42..0000000
--- a/src/synthesizer/src/soundfont/sampledata.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-pub struct SoundFontSampleData {
-    pub bits_per_sample: i32,
-    pub wave_data: Vec<i16>,
-}
-
-impl SoundFontSampleData {
-    pub(crate) fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let chunk_id = BinaryReader::read_four_cc(reader)?;
-        if chunk_id != b"LIST" {
-            return Err(SoundFontError::ListChunkNotFound);
-        }
-
-        let end = BinaryReader::read_u32(reader)? as usize;
-        let reader = &mut ReadCounter::new(reader);
-
-        let list_type = BinaryReader::read_four_cc(reader)?;
-        if list_type != b"sdta" {
-            return Err(SoundFontError::InvalidListChunkType {
-                expected: FourCC::from_bytes(*b"sdta"),
-                actual: list_type,
-            });
-        }
-
-        let mut wave_data: Option<Vec<i16>> = None;
-
-        while reader.bytes_read() < end {
-            let id = BinaryReader::read_four_cc(reader)?;
-            let size = BinaryReader::read_u32(reader)? as usize;
-
-            match id.as_bytes() {
-                b"smpl" => wave_data = Some(BinaryReader::read_wave_data(reader, size)?),
-                b"sm24" => BinaryReader::discard_data(reader, size)?,
-                _ => return Err(SoundFontError::ListContainsUnknownId(id)),
-            }
-        }
-
-        let wave_data = match wave_data {
-            Some(value) => value,
-            None => return Err(SoundFontError::SampleDataNotFound),
-        };
-
-        let ptr = wave_data.as_ptr() as *const u8;
-        let four_cc = unsafe { slice::from_raw_parts(ptr, 4) };
-        if four_cc == b"OggS" {
-            return Err(SoundFontError::UnsupportedSampleFormat);
-        }
-
-        Ok(Self {
-            bits_per_sample: 16,
-            wave_data,
-        })
-    }
-}
diff --git a/src/synthesizer/src/soundfont/version.rs b/src/synthesizer/src/soundfont/version.rs
deleted file mode 100644
index be65da4..0000000
--- a/src/synthesizer/src/soundfont/version.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-#![allow(dead_code)]
-
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-/// Reperesents the version of a SoundFont.
-#[derive(Clone, Debug)]
-pub struct SoundFontVersion {
-    pub(crate) major: i16,
-    pub(crate) minor: i16,
-}
-
-impl SoundFontVersion {
-    pub(crate) fn default() -> Self {
-        Self { major: 0, minor: 0 }
-    }
-
-    pub(crate) fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, io::Error> {
-        let major = BinaryReader::read_i16(reader)?;
-        let minor = BinaryReader::read_i16(reader)?;
-
-        Ok(Self { major, minor })
-    }
-
-    /// Gets the major version.
-    pub fn get_major(&self) -> i32 {
-        self.major as i32
-    }
-
-    /// Gets the minor version.
-    pub fn get_minor(&self) -> i32 {
-        self.minor as i32
-    }
-}
diff --git a/src/synthesizer/src/soundfont/zone/info.rs b/src/synthesizer/src/soundfont/zone/info.rs
deleted file mode 100644
index e4105c8..0000000
--- a/src/synthesizer/src/soundfont/zone/info.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-pub(crate) struct ZoneInfo {
-    pub(crate) generator_index: i32,
-    pub(crate) modulator_index: i32,
-    pub(crate) generator_count: i32,
-    pub(crate) modulator_count: i32,
-}
-
-impl ZoneInfo {
-    fn new<R: Read + ?Sized>(reader: &mut R) -> Result<Self, SoundFontError> {
-        let generator_index = BinaryReader::read_u16(reader)? as i32;
-        let modulator_index = BinaryReader::read_u16(reader)? as i32;
-
-        Ok(Self {
-            generator_index,
-            modulator_index,
-            generator_count: 0,
-            modulator_count: 0,
-        })
-    }
-
-    pub(crate) fn read_from_chunk<R: Read + ?Sized>(
-        reader: &mut R,
-        size: usize,
-    ) -> Result<Vec<ZoneInfo>, SoundFontError> {
-        if size % 4 != 0 {
-            return Err(SoundFontError::InvalidZoneList);
-        }
-
-        let count = size / 4;
-
-        let mut zones: Vec<ZoneInfo> = Vec::new();
-        for _i in 0..count {
-            zones.push(ZoneInfo::new(reader)?);
-        }
-
-        for i in 0..(count - 1) {
-            zones[i].generator_count = zones[i + 1].generator_index - zones[i].generator_index;
-            zones[i].modulator_count = zones[i + 1].modulator_index - zones[i].modulator_index;
-        }
-
-        Ok(zones)
-    }
-}
diff --git a/src/synthesizer/src/soundfont/zone/mod.rs b/src/synthesizer/src/soundfont/zone/mod.rs
deleted file mode 100644
index 3b09c24..0000000
--- a/src/synthesizer/src/soundfont/zone/mod.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-mod info;
-
-pub(super) use info::ZoneInfo;
-
-use crate::prelude::*;
-
-pub(crate) struct Zone {
-    pub(crate) generators: Vec<Generator>,
-}
-
-impl Zone {
-    pub(crate) fn empty() -> Self {
-        Self {
-            generators: Vec::new(),
-        }
-    }
-
-    fn new(info: &ZoneInfo, generators: &[Generator]) -> Self {
-        let mut segment: Vec<Generator> = Vec::new();
-
-        for i in 0..info.generator_count {
-            segment.push(generators[(info.generator_index + i) as usize]);
-        }
-
-        Self {
-            generators: segment,
-        }
-    }
-
-    pub(crate) fn create(
-        infos: &[ZoneInfo],
-        generators: &[Generator],
-    ) -> Result<Vec<Zone>, SoundFontError> {
-        if infos.len() <= 1 {
-            return Err(SoundFontError::ZoneNotFound);
-        }
-
-        // The last one is the terminator.
-        let count = infos.len() - 1;
-
-        let mut zones: Vec<Zone> = Vec::new();
-        for info in infos.iter().take(count) {
-            zones.push(Zone::new(info, generators));
-        }
-
-        Ok(zones)
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/array_math.rs b/src/synthesizer/src/synthesizer/array_math.rs
deleted file mode 100644
index 2531a34..0000000
--- a/src/synthesizer/src/synthesizer/array_math.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-pub(crate) struct ArrayMath {}
-
-impl ArrayMath {
-    pub(crate) fn multiply_add(a: f32, x: &[f32], destination: &mut [f32]) {
-        for (x, destination) in x.iter().zip(destination.iter_mut()) {
-            *destination += a * *x;
-        }
-    }
-
-    pub(crate) fn multiply_add_slope(a: f32, step: f32, x: &[f32], destination: &mut [f32]) {
-        let mut a = a;
-        for (x, destination) in x.iter().zip(destination.iter_mut()) {
-            *destination += a * *x;
-            a += step;
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/channel.rs b/src/synthesizer/src/synthesizer/channel.rs
deleted file mode 100644
index 1304120..0000000
--- a/src/synthesizer/src/synthesizer/channel.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-#[derive(PartialEq, Eq)]
-enum DataType {
-    None,
-    Rpn,
-    Nrpn,
-}
-
-pub(crate) struct Channel {
-    pub(crate) is_percussion_channel: bool,
-
-    bank_number: u8,
-    patch_number: u8,
-
-    modulation: u16,
-    volume: u16,
-    pan: u16,
-    expression: u16,
-    hold_pedal: bool,
-
-    reverb_send: u8,
-    chorus_send: u8,
-
-    rpn: u16,
-    pitch_bend_range: u16,
-    coarse_tune: u16,
-    fine_tune: u16,
-
-    pitch_bend: f32,
-
-    last_data_type: DataType,
-}
-
-impl Channel {
-    pub(crate) fn new(is_percussion_channel: bool) -> Self {
-        let mut channel = Self {
-            is_percussion_channel,
-            bank_number: 0,
-            patch_number: 0,
-            modulation: 0,
-            volume: 0,
-            pan: 0,
-            expression: 0,
-            hold_pedal: false,
-            reverb_send: 0,
-            chorus_send: 0,
-            rpn: 0,
-            pitch_bend_range: 0,
-            coarse_tune: 0,
-            fine_tune: 0,
-            pitch_bend: 0_f32,
-            last_data_type: DataType::None,
-        };
-
-        channel.reset();
-
-        channel
-    }
-
-    pub(crate) fn reset(&mut self) {
-        self.bank_number = if self.is_percussion_channel { 128 } else { 0 };
-        self.patch_number = 0;
-
-        self.modulation = 0;
-        self.volume = 100 << 7;
-        self.pan = 64 << 7;
-        self.expression = 127 << 7;
-        self.hold_pedal = false;
-
-        self.reverb_send = 40;
-        self.chorus_send = 0;
-
-        self.rpn = 0xFFFF;
-        self.pitch_bend_range = 2 << 7;
-        self.coarse_tune = 0;
-        self.fine_tune = 8192;
-
-        self.pitch_bend = 0_f32;
-    }
-
-    pub(crate) fn reset_all_controllers(&mut self) {
-        self.modulation = 0;
-        self.expression = 127 << 7;
-        self.hold_pedal = false;
-
-        self.rpn = 0xFFFF;
-
-        self.pitch_bend = 0_f32;
-    }
-
-    pub(crate) fn set_bank(&mut self, value: u8) {
-        self.bank_number = value;
-
-        if self.is_percussion_channel {
-            self.bank_number += 128;
-        }
-    }
-
-    pub(crate) fn set_patch(&mut self, value: u8) {
-        self.patch_number = value;
-    }
-
-    pub(crate) fn set_modulation_coarse(&mut self, value: u8) {
-        self.modulation = (self.modulation & 0x7F) | ((value as u16) << 7);
-    }
-
-    pub(crate) fn set_modulation_fine(&mut self, value: u8) {
-        self.modulation = (self.modulation & 0xFF80) | value as u16;
-    }
-
-    pub(crate) fn set_volume_coarse(&mut self, value: u8) {
-        self.volume = (self.volume & 0x7F) | ((value as u16) << 7);
-    }
-
-    pub(crate) fn set_volume_fine(&mut self, value: u8) {
-        self.volume = (self.volume & 0xFF80) | value as u16;
-    }
-
-    pub(crate) fn set_pan_coarse(&mut self, value: u8) {
-        self.pan = (self.pan & 0x7F) | ((value as u16) << 7);
-    }
-
-    pub(crate) fn set_pan_fine(&mut self, value: u8) {
-        self.pan = (self.pan & 0xFF80) | value as u16;
-    }
-
-    pub(crate) fn set_expression_coarse(&mut self, value: u8) {
-        self.expression = (self.expression & 0x7F) | ((value as u16) << 7);
-    }
-
-    pub(crate) fn set_expression_fine(&mut self, value: u8) {
-        self.expression = (self.expression & 0xFF80) | value as u16;
-    }
-
-    pub(crate) fn set_hold_pedal(&mut self, value: u8) {
-        self.hold_pedal = value >= 64;
-    }
-
-    pub(crate) fn set_reverb_send(&mut self, value: u8) {
-        self.reverb_send = value;
-    }
-
-    pub(crate) fn set_chorus_send(&mut self, value: u8) {
-        self.chorus_send = value;
-    }
-
-    pub(crate) fn set_rpn_coarse(&mut self, value: u8) {
-        self.rpn = (self.rpn & 0x7F) | ((value as u16) << 7);
-        self.last_data_type = DataType::Rpn;
-    }
-
-    pub(crate) fn set_rpn_fine(&mut self, value: u8) {
-        self.rpn = (self.rpn & 0xFF80) | value as u16;
-        self.last_data_type = DataType::Rpn;
-    }
-
-    pub(crate) fn set_nrpn_coarse(&mut self) {
-        self.last_data_type = DataType::Nrpn;
-    }
-
-    pub(crate) fn set_nrpn_fine(&mut self) {
-        self.last_data_type = DataType::Nrpn;
-    }
-
-    pub(crate) fn data_entry_coarse(&mut self, value: u8) {
-        if self.last_data_type != DataType::Rpn {
-            return;
-        }
-
-        if self.rpn == 0 {
-            self.pitch_bend_range = (self.pitch_bend_range & 0x7F) | ((value as u16) << 7);
-        } else if self.rpn == 1 {
-            self.fine_tune = (self.fine_tune & 0x7F) | ((value as u16) << 7);
-        } else if self.rpn == 2 {
-            //TODO: what
-            self.coarse_tune = (value as u16) - 64;
-        }
-    }
-
-    pub(crate) fn data_entry_fine(&mut self, value: u8) {
-        if self.last_data_type != DataType::Rpn {
-            return;
-        }
-
-        if self.rpn == 0 {
-            self.pitch_bend_range = (self.pitch_bend_range & 0xFF80) | value as u16;
-        } else if self.rpn == 1 {
-            self.fine_tune = (self.fine_tune & 0xFF80) | value as u16;
-        }
-    }
-
-    pub(crate) fn set_pitch_bend(&mut self, lsb: u8, msb: u8) {
-        self.pitch_bend = (1_f32 / 8192_f32) * ((lsb as i32 | ((msb as i32) << 7)) - 8192) as f32;
-    }
-
-    pub(crate) fn get_bank_number(&self) -> u8 {
-        self.bank_number
-    }
-
-    pub(crate) fn get_patch_number(&self) -> u8 {
-        self.patch_number
-    }
-
-    pub(crate) fn get_modulation(&self) -> f32 {
-        (50_f32 / 16383_f32) * self.modulation as f32
-    }
-
-    pub(crate) fn get_volume(&self) -> f32 {
-        (1_f32 / 16383_f32) * self.volume as f32
-    }
-
-    pub(crate) fn get_pan(&self) -> f32 {
-        (100_f32 / 16383_f32) * self.pan as f32 - 50_f32
-    }
-
-    pub(crate) fn get_expression(&self) -> f32 {
-        (1_f32 / 16383_f32) * self.expression as f32
-    }
-
-    pub(crate) fn get_hold_pedal(&self) -> bool {
-        self.hold_pedal
-    }
-
-    pub(crate) fn get_reverb_send(&self) -> f32 {
-        (1_f32 / 127_f32) * self.reverb_send as f32
-    }
-
-    pub(crate) fn get_chorus_send(&self) -> f32 {
-        (1_f32 / 127_f32) * self.chorus_send as f32
-    }
-
-    pub(crate) fn get_pitch_bend_range(&self) -> f32 {
-        (self.pitch_bend_range >> 7) as f32 + 0.01_f32 * (self.pitch_bend_range & 0x7F) as f32
-    }
-
-    pub(crate) fn get_tune(&self) -> f32 {
-        self.coarse_tune as f32 + (1_f32 / 8192_f32) * (self.fine_tune - 8192) as f32
-    }
-
-    pub(crate) fn get_pitch_bend(&self) -> f32 {
-        self.get_pitch_bend_range() * self.pitch_bend
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/chorus.rs b/src/synthesizer/src/synthesizer/chorus.rs
deleted file mode 100644
index c741591..0000000
--- a/src/synthesizer/src/synthesizer/chorus.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use bevy_platform::prelude::*;
-pub(crate) struct Chorus {
-    buffer_l: Vec<f32>,
-    buffer_r: Vec<f32>,
-
-    delay_table: Vec<f32>,
-
-    buffer_index: usize,
-
-    delay_table_index_l: usize,
-    delay_table_index_r: usize,
-}
-
-impl Chorus {
-    pub(crate) fn new(sample_rate: i32, delay: f64, depth: f64, frequency: f64) -> Self {
-        let buffer_l = vec![0_f32; ((sample_rate as f64) * (delay + depth)) as usize + 2];
-        let buffer_r = vec![0_f32; ((sample_rate as f64) * (delay + depth)) as usize + 2];
-
-        let mut delay_table = vec![0_f32; ((sample_rate as f64) / frequency).round() as usize];
-        let delay_table_length = delay_table.len();
-        for (t, input) in delay_table.iter_mut().enumerate().take(delay_table_length) {
-            let phase = 2.0 * consts::PI * (t as f64) / (delay_table_length as f64);
-            *input = ((sample_rate as f64) * (delay + depth * phase.sin())) as f32;
-        }
-
-        let buffer_index: usize = 0;
-
-        let delay_table_index_l: usize = 0;
-        let delay_table_index_r: usize = delay_table_length / 4;
-
-        Self {
-            buffer_l,
-            buffer_r,
-            delay_table,
-            buffer_index,
-            delay_table_index_l,
-            delay_table_index_r,
-        }
-    }
-
-    pub(crate) fn process(
-        &mut self,
-        input_left: &[f32],
-        input_right: &[f32],
-        output_left: &mut [f32],
-        output_right: &mut [f32],
-    ) {
-        let buffer_length = self.buffer_l.len();
-        let delay_table_length = self.delay_table.len();
-        let output_length = output_left.len();
-
-        for t in 0..output_length {
-            {
-                let mut position =
-                    self.buffer_index as f64 - self.delay_table[self.delay_table_index_l] as f64;
-                if position < 0.0 {
-                    position += buffer_length as f64;
-                }
-
-                let index1 = position as usize;
-                let mut index2 = index1 + 1;
-                if index2 == buffer_length {
-                    index2 = 0;
-                }
-
-                let x1 = self.buffer_l[index1] as f64;
-                let x2 = self.buffer_l[index2] as f64;
-                let a = position - index1 as f64;
-                output_left[t] = (x1 + a * (x2 - x1)) as f32;
-
-                self.delay_table_index_l += 1;
-                if self.delay_table_index_l == delay_table_length {
-                    self.delay_table_index_l = 0;
-                }
-            }
-
-            {
-                let mut position =
-                    self.buffer_index as f64 - self.delay_table[self.delay_table_index_r] as f64;
-                if position < 0.0 {
-                    position += buffer_length as f64;
-                }
-
-                let index1 = position as usize;
-                let mut index2 = index1 + 1;
-                if index2 == buffer_length {
-                    index2 = 0;
-                }
-
-                let x1 = self.buffer_r[index1] as f64;
-                let x2 = self.buffer_r[index2] as f64;
-                let a = position - index1 as f64;
-                output_right[t] = (x1 + a * (x2 - x1)) as f32;
-
-                self.delay_table_index_r += 1;
-                if self.delay_table_index_r == delay_table_length {
-                    self.delay_table_index_r = 0;
-                }
-            }
-
-            self.buffer_l[self.buffer_index] = input_left[t];
-            self.buffer_r[self.buffer_index] = input_right[t];
-            self.buffer_index += 1;
-            if self.buffer_index == buffer_length {
-                self.buffer_index = 0;
-            }
-        }
-    }
-
-    pub(crate) fn mute(&mut self) {
-        let buffer_length = self.buffer_l.len();
-
-        for t in 0..buffer_length {
-            self.buffer_l[t] = 0_f32;
-        }
-
-        for t in 0..buffer_length {
-            self.buffer_r[t] = 0_f32;
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/error.rs b/src/synthesizer/src/synthesizer/error.rs
deleted file mode 100644
index 558c9ed..0000000
--- a/src/synthesizer/src/synthesizer/error.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use bevy_platform::prelude::*;
-/// Represents an error when initializing a synthesizer.
-#[derive(Debug)]
-pub enum SynthesizerError {
-    SampleRateOutOfRange(i32),
-    BlockSizeOutOfRange(usize),
-    MaximumPolyphonyOutOfRange(usize),
-}
-
-impl error::Error for SynthesizerError {}
-
-impl fmt::Display for SynthesizerError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            SynthesizerError::SampleRateOutOfRange(value) => write!(
-                f,
-                "the sample rate must be between 16000 and 192000, but was {value}",
-            ),
-            SynthesizerError::BlockSizeOutOfRange(value) => write!(
-                f,
-                "the block size must be between 8 and 1024, but was {value}",
-            ),
-            SynthesizerError::MaximumPolyphonyOutOfRange(value) => {
-                write!(
-                    f,
-                    "the maximum number of polyphony must be between 8 and 256, but was {value}",
-                )
-            }
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/loop_mode.rs b/src/synthesizer/src/synthesizer/loop_mode.rs
deleted file mode 100644
index 653f906..0000000
--- a/src/synthesizer/src/synthesizer/loop_mode.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-/// Specifies how the sample loops during playback.
-#[derive(Debug, PartialEq, Eq)]
-pub enum LoopMode {
-    /// The sample will be played without loop.
-    NoLoop,
-    /// The sample will loop continuously.
-    Continuous,
-    /// The sample will loop until the note stops.
-    LoopUntilNoteOff,
-}
-
-impl LoopMode {
-    pub(crate) fn from_i16(value: i16) -> Self {
-        match value {
-            1 => LoopMode::Continuous,
-            3 => LoopMode::LoopUntilNoteOff,
-            _ => LoopMode::NoLoop,
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/mod.rs b/src/synthesizer/src/synthesizer/mod.rs
deleted file mode 100644
index 904088f..0000000
--- a/src/synthesizer/src/synthesizer/mod.rs
+++ /dev/null
@@ -1,602 +0,0 @@
-pub mod voice;
-
-mod chorus;
-use chorus::*;
-
-mod reverb;
-use reverb::*;
-
-mod settings;
-pub use settings::*;
-
-mod error;
-pub use error::*;
-
-mod array_math;
-use array_math::*;
-
-mod loop_mode;
-pub use loop_mode::*;
-
-mod channel;
-use channel::*;
-use voice::{RegionPair, Voice};
-
-use crate::{prelude::*, utils};
-use bevy_platform::prelude::*;
-
-/// An instance of the SoundFont synthesizer.
-pub struct Synthesizer {
-    pub(crate) sound_font: SoundFont,
-    pub(crate) sample_rate: i32,
-    pub(crate) block_size: usize,
-    pub(crate) maximum_polyphony: usize,
-
-    settings: SynthesizerSettings,
-
-    preset_lookup: HashMap<i32, usize>,
-    default_preset: usize,
-
-    channels: Vec<Channel>,
-
-    voices: Vec<Voice>,
-
-    block_left: Vec<f32>,
-    block_right: Vec<f32>,
-
-    inverse_block_size: f32,
-
-    block_read: usize,
-
-    master_volume: f32,
-
-    effects: Option<Effects>,
-}
-
-impl Synthesizer {
-    /// The number of channels.
-    /// The percussion channel.
-    pub const PERCUSSION_CHANNEL: usize = 9;
-
-    /// Initializes a new synthesizer using a specified SoundFont and settings.
-    ///
-    /// # Arguments
-    ///
-    /// * `sound_font` - The SoundFont instance.
-    /// * `settings` - The settings for synthesis.
-    pub fn new(
-        sound_font: SoundFont,
-        settings: &SynthesizerSettings,
-    ) -> Result<Self, SynthesizerError> {
-        settings.validate()?;
-
-        let mut preset_lookup: HashMap<i32, usize> = HashMap::new();
-
-        let mut min_preset_id = i32::MAX;
-        let mut default_preset: usize = 0;
-
-        sound_font
-            .presets
-            .iter()
-            .enumerate()
-            .for_each(|(i, preset)| {
-                // The preset ID is Int32, where the upper 16 bits represent the bank number
-                // and the lower 16 bits represent the patch number.
-                // This ID is used to search for presets by the combination of bank number
-                // and patch number.
-                let preset_id = (preset.bank_number << 16) | preset.patch_number;
-                preset_lookup.insert(preset_id, i);
-
-                // The preset with the minimum ID number will be default.
-                // If the SoundFont is GM compatible, the piano will be chosen.
-                if preset_id < min_preset_id {
-                    default_preset = i;
-                    min_preset_id = preset_id;
-                }
-            });
-
-        const CHANNEL_COUNT: usize = 16;
-        let channels: Vec<Channel> = (0..CHANNEL_COUNT)
-            .map(|i| Channel::new(i == Synthesizer::PERCUSSION_CHANNEL))
-            .collect();
-
-        let block_left: Vec<f32> = vec![0_f32; settings.block_size];
-        let block_right: Vec<f32> = vec![0_f32; settings.block_size];
-
-        let inverse_block_size = 1_f32 / settings.block_size as f32;
-
-        let block_read = settings.block_size;
-
-        let master_volume = 0.5_f32;
-
-        let effects = if settings.enable_reverb_and_chorus {
-            Some(Effects::new(settings))
-        } else {
-            None
-        };
-
-        Ok(Self {
-            sound_font,
-            sample_rate: settings.sample_rate,
-            block_size: settings.block_size,
-            maximum_polyphony: settings.maximum_polyphony,
-            preset_lookup,
-            default_preset,
-            channels,
-            settings: *settings,
-            voices: Vec::with_capacity(settings.maximum_polyphony),
-            block_left,
-            block_right,
-            inverse_block_size,
-            block_read,
-            master_volume,
-            effects,
-        })
-    }
-
-    /// Processes a MIDI message.
-    ///
-    /// # Arguments
-    ///
-    /// * `channel` - The channel to which the message will be sent.
-    /// * `command` - The type of the message.
-    /// * `data1` - The first data part of the message.
-    /// * `data2` - The second data part of the message.
-    pub fn process_midi_message(&mut self, status: u8, data1: u8, data2: u8) {
-        let channel = status & 0x0F;
-        let command = status & 0xF0;
-
-        if channel as usize >= self.channels.len() {
-            return;
-        }
-
-        let channel_info = &mut self.channels[channel as usize];
-
-        match command {
-            0x80 => self.note_off(channel, data1),       // Note Off
-            0x90 => self.note_on(channel, data1, data2), // Note On
-            0xB0 => match data1 // Controller
-            {
-                0x00 => channel_info.set_bank(data2), // Bank Selection
-                0x01 => channel_info.set_modulation_coarse(data2), // Modulation Coarse
-                0x21 => channel_info.set_modulation_fine(data2), // Modulation Fine
-                0x06 => channel_info.data_entry_coarse(data2), // Data Entry Coarse
-                0x26 => channel_info.data_entry_fine(data2), // Data Entry Fine
-                0x07 => channel_info.set_volume_coarse(data2), // Channel Volume Coarse
-                0x27 => channel_info.set_volume_fine(data2), // Channel Volume Fine
-                0x0A => channel_info.set_pan_coarse(data2), // Pan Coarse
-                0x2A => channel_info.set_pan_fine(data2), // Pan Fine
-                0x0B => channel_info.set_expression_coarse(data2), // Expression Coarse
-                0x2B => channel_info.set_expression_fine(data2), // Expression Fine
-                0x40 => channel_info.set_hold_pedal(data2), // Hold Pedal
-                0x5B => channel_info.set_reverb_send(data2), // Reverb Send
-                0x5D => channel_info.set_chorus_send(data2), // Chorus Send
-                //Note, this used to not use data 2
-                0x63 => channel_info.set_nrpn_coarse(), // NRPN Coarse
-                //Note: this used to not use data 2
-                0x62 => channel_info.set_nrpn_fine(), // NRPN Fine
-                0x65 => channel_info.set_rpn_coarse(data2), // RPN Coarse
-                0x64 => channel_info.set_rpn_fine(data2), // RPN Fine
-
-                0x78 => self.note_off_all_channel(channel, true), // All Sound Off
-                0x79 => self.reset_all_controllers_channel(channel), // Reset All Controllers
-                0x7B => self.note_off_all_channel(channel, false), // All Note Off
-                _ => (),
-            },
-            0xC0 => channel_info.set_patch(data1), // Program Change
-            0xE0 => channel_info.set_pitch_bend(data1, data2), // Pitch Bend
-            _ => (),
-        }
-    }
-
-    /// Stops a note.
-    ///
-    /// # Arguments
-    ///
-    /// * `channel` - The channel of the note.
-    /// * `key` - The key of the note.
-    pub fn note_off(&mut self, channel: u8, key: u8) {
-        if channel as usize >= self.channels.len() {
-            return;
-        }
-
-        for voice in self.voices.iter_mut() {
-            if voice.channel == channel && voice.key == key {
-                voice.end();
-            }
-        }
-    }
-
-    /// Starts a note.
-    ///
-    /// # Arguments
-    ///
-    /// * `channel` - The channel of the note.
-    /// * `key` - The key of the note.
-    /// * `velocity` - The velocity of the note.
-    pub fn note_on(&mut self, channel: u8, key: u8, velocity: u8) {
-        if velocity == 0 {
-            self.note_off(channel, key);
-            return;
-        }
-
-        if channel as usize >= self.channels.len() {
-            return;
-        }
-
-        let channel_info = &self.channels[channel as usize];
-
-        let preset_id = ((channel_info.get_bank_number() as i32) << 16)
-            | channel_info.get_patch_number() as i32;
-
-        let preset = match self.preset_lookup.get(&preset_id) {
-            Some(value) => *value,
-            None => {
-                // Try fallback to the GM sound set.
-                // Normally, the given patch number + the bank number 0 will work.
-                // For drums (bank number >= 128), it seems to be better to select the standard set (128:0).
-                //
-                // todo: dsgallups
-                let gm_preset_id = if channel_info.get_bank_number() < 128 {
-                    channel_info.get_patch_number() as i32
-                } else {
-                    128 << 16
-                };
-
-                // If no corresponding preset was found. Use the default one...
-                if let Some(value) = self.preset_lookup.get(&gm_preset_id) {
-                    *value
-                } else {
-                    self.default_preset
-                }
-            }
-        };
-
-        let preset = &self.sound_font.presets[preset];
-        for preset_region in preset.regions.iter() {
-            if preset_region.contains(key, velocity) {
-                let instrument = &self.sound_font.instruments[preset_region.instrument];
-                for instrument_region in instrument.regions.iter() {
-                    if instrument_region.contains(key, velocity) {
-                        let region_pair = RegionPair::new(preset_region, instrument_region);
-
-                        // If an exclusive class is assigned to the region, find a voice with the same class.
-                        // If found, reuse it to avoid playing multiple voices with the same class at a time.
-                        let exclusive_class = instrument_region.get_exclusive_class();
-
-                        if exclusive_class != 0 {
-                            for voice in self.voices.iter_mut() {
-                                if voice.exclusive_class == exclusive_class
-                                    && voice.channel == channel
-                                {
-                                    //this is identical to what existed before. Instant drop.
-                                    *voice = Voice::new(
-                                        &self.settings,
-                                        &region_pair,
-                                        channel,
-                                        key,
-                                        velocity,
-                                    );
-                                    return;
-                                }
-                            }
-                        }
-
-                        self.voices.push(Voice::new(
-                            &self.settings,
-                            &region_pair,
-                            channel,
-                            key,
-                            velocity,
-                        ));
-                    }
-                }
-            }
-        }
-    }
-
-    /// Stops all the notes in the specified channel.
-    ///
-    /// # Arguments
-    ///
-    /// * `immediate` - If `true`, notes will stop immediately without the release sound.
-    pub fn note_off_all(&mut self, immediate: bool) {
-        if immediate {
-            self.voices.clear();
-        } else {
-            for voice in self.voices.iter_mut() {
-                voice.end();
-            }
-        }
-    }
-
-    /// Stops all the notes in the specified channel.
-    ///
-    /// # Arguments
-    ///
-    /// * `channel` - The channel in which the notes will be stopped.
-    /// * `immediate` - If `true`, notes will stop immediately without the release sound.
-    pub fn note_off_all_channel(&mut self, channel: u8, immediate: bool) {
-        if immediate {
-            self.voices.retain(|voice| voice.channel != channel);
-        } else {
-            self.voices.iter_mut().for_each(|voice| {
-                if voice.channel == channel {
-                    voice.end();
-                }
-            });
-        }
-    }
-
-    /// Resets all the controllers.
-    pub fn reset_all_controllers(&mut self) {
-        for channel in &mut self.channels {
-            channel.reset_all_controllers();
-        }
-    }
-
-    /// Resets all the controllers of the specified channel.
-    ///
-    /// # Arguments
-    ///
-    /// * `channel` - The channel to be reset.
-    pub fn reset_all_controllers_channel(&mut self, channel: u8) {
-        if channel as usize >= self.channels.len() {
-            return;
-        }
-
-        self.channels[channel as usize].reset_all_controllers();
-    }
-
-    /// Resets the synthesizer.
-    pub fn reset(&mut self) {
-        self.voices.clear();
-
-        for channel in &mut self.channels {
-            channel.reset();
-        }
-
-        if let Some(effects) = self.effects.as_mut() {
-            effects.reverb.mute();
-            effects.chorus.mute();
-        }
-
-        self.block_read = self.block_size;
-    }
-
-    /// Renders the waveform.
-    ///
-    /// # Arguments
-    ///
-    /// * `left` - The buffer of the left channel to store the rendered waveform.
-    /// * `right` - The buffer of the right channel to store the rendered waveform.
-    ///
-    /// # Remarks
-    ///
-    /// The output buffers for the left and right must be the same length.
-    pub fn render(&mut self, left: &mut [f32], right: &mut [f32]) {
-        if left.len() != right.len() {
-            panic!("The output buffers for the left and right must be the same length.");
-        }
-
-        let left_length = left.len();
-
-        let mut wrote = 0;
-        while wrote < left_length {
-            if self.block_read == self.block_size {
-                self.render_block();
-                self.block_read = 0;
-            }
-
-            let src_rem = self.block_size - self.block_read;
-            let dst_rem = left_length - wrote;
-            let rem = cmp::min(src_rem, dst_rem);
-
-            for t in 0..rem {
-                left[wrote + t] = self.block_left[self.block_read + t];
-                right[wrote + t] = self.block_right[self.block_read + t];
-            }
-
-            self.block_read += rem;
-            wrote += rem;
-        }
-    }
-
-    fn render_block(&mut self) {
-        // the idea here is that if the voice cannot process, drop it.
-        // A voice will not be able to process if it's been killed and is ready for release.
-        self.voices
-            .retain_mut(|voice| voice.process(&self.sound_font.wave_data, &self.channels));
-
-        self.block_left.fill(0_f32);
-        self.block_right.fill(0_f32);
-
-        for voice in self.voices.iter_mut() {
-            let previous_gain_left = self.master_volume * voice.previous_mix_gain_left;
-            let current_gain_left = self.master_volume * voice.current_mix_gain_left;
-            Synthesizer::write_block(
-                previous_gain_left,
-                current_gain_left,
-                &voice.block,
-                &mut self.block_left,
-                self.inverse_block_size,
-            );
-            let previous_gain_right = self.master_volume * voice.previous_mix_gain_right;
-            let current_gain_right = self.master_volume * voice.current_mix_gain_right;
-            Synthesizer::write_block(
-                previous_gain_right,
-                current_gain_right,
-                &voice.block,
-                &mut self.block_right,
-                self.inverse_block_size,
-            );
-        }
-
-        if let Some(effects) = self.effects.as_mut() {
-            let chorus = &mut effects.chorus;
-            let chorus_input_left = &mut effects.chorus_input_left[..];
-            let chorus_input_right = &mut effects.chorus_input_right[..];
-            let chorus_output_left = &mut effects.chorus_output_left[..];
-            let chorus_output_right = &mut effects.chorus_output_right[..];
-            chorus_input_left.fill(0_f32);
-            chorus_input_right.fill(0_f32);
-            for voice in self.voices.iter_mut() {
-                let previous_gain_left = voice.previous_chorus_send * voice.previous_mix_gain_left;
-                let current_gain_left = voice.current_chorus_send * voice.current_mix_gain_left;
-                Synthesizer::write_block(
-                    previous_gain_left,
-                    current_gain_left,
-                    &voice.block[..],
-                    chorus_input_left,
-                    self.inverse_block_size,
-                );
-                let previous_gain_right =
-                    voice.previous_chorus_send * voice.previous_mix_gain_right;
-                let current_gain_right = voice.current_chorus_send * voice.current_mix_gain_right;
-                Synthesizer::write_block(
-                    previous_gain_right,
-                    current_gain_right,
-                    &voice.block[..],
-                    chorus_input_right,
-                    self.inverse_block_size,
-                );
-            }
-            chorus.process(
-                chorus_input_left,
-                chorus_input_right,
-                chorus_output_left,
-                chorus_output_right,
-            );
-            ArrayMath::multiply_add(
-                self.master_volume,
-                chorus_output_left,
-                &mut self.block_left[..],
-            );
-            ArrayMath::multiply_add(
-                self.master_volume,
-                chorus_output_right,
-                &mut self.block_right[..],
-            );
-
-            let reverb = &mut effects.reverb;
-            let reverb_input = &mut effects.reverb_input[..];
-            let reverb_output_left = &mut effects.reverb_output_left[..];
-            let reverb_output_right = &mut effects.reverb_output_right[..];
-            reverb_input.fill(0_f32);
-            for voice in self.voices.iter_mut() {
-                let previous_gain = reverb.get_input_gain()
-                    * voice.previous_reverb_send
-                    * (voice.previous_mix_gain_left + voice.previous_mix_gain_right);
-                let current_gain = reverb.get_input_gain()
-                    * voice.current_reverb_send
-                    * (voice.current_mix_gain_left + voice.current_mix_gain_right);
-                Synthesizer::write_block(
-                    previous_gain,
-                    current_gain,
-                    &voice.block[..],
-                    &mut reverb_input[..],
-                    self.inverse_block_size,
-                );
-            }
-
-            reverb.process(reverb_input, reverb_output_left, reverb_output_right);
-            ArrayMath::multiply_add(
-                self.master_volume,
-                reverb_output_left,
-                &mut self.block_left[..],
-            );
-            ArrayMath::multiply_add(
-                self.master_volume,
-                reverb_output_right,
-                &mut self.block_right[..],
-            );
-        }
-    }
-
-    fn write_block(
-        previous_gain: f32,
-        current_gain: f32,
-        source: &[f32],
-        destination: &mut [f32],
-        inverse_block_size: f32,
-    ) {
-        if previous_gain.max(current_gain) < utils::NON_AUDIBLE {
-            return;
-        }
-
-        if (current_gain - previous_gain).abs() < utils::NON_AUDIBLE {
-            ArrayMath::multiply_add(current_gain, source, destination);
-        } else {
-            let step = inverse_block_size * (current_gain - previous_gain);
-            ArrayMath::multiply_add_slope(previous_gain, step, source, destination);
-        }
-    }
-
-    /// Gets the SoundFont used as the audio source.
-    pub fn get_sound_font(&self) -> &SoundFont {
-        &self.sound_font
-    }
-
-    /// Gets the sample rate for synthesis.
-    pub fn get_sample_rate(&self) -> i32 {
-        self.sample_rate
-    }
-
-    /// Gets the block size for rendering waveform.
-    pub fn get_block_size(&self) -> usize {
-        self.block_size
-    }
-
-    /// Gets the number of maximum polyphony.
-    pub fn get_maximum_polyphony(&self) -> usize {
-        self.maximum_polyphony
-    }
-
-    /// Gets the value indicating whether reverb and chorus are enabled.
-    pub fn get_enable_reverb_and_chorus(&self) -> bool {
-        self.effects.is_some()
-    }
-
-    /// Gets the master volume.
-    pub fn get_master_volume(&self) -> f32 {
-        self.master_volume
-    }
-
-    /// Sets the master volume.
-    ///
-    /// # Arguments
-    ///
-    /// * `value` - The new value of the master volume.
-    pub fn set_master_volume(&mut self, value: f32) {
-        self.master_volume = value;
-    }
-}
-
-struct Effects {
-    reverb: Reverb,
-    reverb_input: Vec<f32>,
-    reverb_output_left: Vec<f32>,
-    reverb_output_right: Vec<f32>,
-
-    chorus: Chorus,
-    chorus_input_left: Vec<f32>,
-    chorus_input_right: Vec<f32>,
-    chorus_output_left: Vec<f32>,
-    chorus_output_right: Vec<f32>,
-}
-
-impl Effects {
-    fn new(settings: &SynthesizerSettings) -> Effects {
-        Self {
-            reverb: Reverb::new(settings.sample_rate),
-            reverb_input: vec![0_f32; settings.block_size],
-            reverb_output_left: vec![0_f32; settings.block_size],
-            reverb_output_right: vec![0_f32; settings.block_size],
-            chorus: Chorus::new(settings.sample_rate, 0.002, 0.0019, 0.4),
-            chorus_input_left: vec![0_f32; settings.block_size],
-            chorus_input_right: vec![0_f32; settings.block_size],
-            chorus_output_left: vec![0_f32; settings.block_size],
-            chorus_output_right: vec![0_f32; settings.block_size],
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/reverb.rs b/src/synthesizer/src/synthesizer/reverb.rs
deleted file mode 100644
index e7e1841..0000000
--- a/src/synthesizer/src/synthesizer/reverb.rs
+++ /dev/null
@@ -1,383 +0,0 @@
-use bevy_platform::prelude::*;
-pub(crate) struct Reverb {
-    left_combfilters: Vec<CombFilter>,
-    left_allpassfilters: Vec<AllPassFilter>,
-
-    right_combfilters: Vec<CombFilter>,
-    right_allpassfilters: Vec<AllPassFilter>,
-
-    gain: f32,
-    room_size: f32,
-    room_size1: f32,
-    damp: f32,
-    damp1: f32,
-    wet: f32,
-    wet1: f32,
-    wet2: f32,
-    width: f32,
-}
-
-impl Reverb {
-    const FIXED_GAIN: f32 = 0.015;
-    const SCALE_WET: f32 = 3.0;
-    const SCALE_DAMP: f32 = 0.4;
-    const SCALE_ROOM: f32 = 0.28;
-    const OFFSET_ROOM: f32 = 0.7;
-    const INITIAL_ROOM: f32 = 0.5;
-    const INITIAL_DAMP: f32 = 0.5;
-    const INITIAL_WET: f32 = 1.0 / Reverb::SCALE_WET;
-    const INITIAL_WIDTH: f32 = 1.0;
-    const STEREO_SPREAD: usize = 23;
-
-    const CF_TUNING_L1: usize = 1116;
-    const CF_TUNING_R1: usize = 1116 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L2: usize = 1188;
-    const CF_TUNING_R2: usize = 1188 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L3: usize = 1277;
-    const CF_TUNING_R3: usize = 1277 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L4: usize = 1356;
-    const CF_TUNING_R4: usize = 1356 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L5: usize = 1422;
-    const CF_TUNING_R5: usize = 1422 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L6: usize = 1491;
-    const CF_TUNING_R6: usize = 1491 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L7: usize = 1557;
-    const CF_TUNING_R7: usize = 1557 + Reverb::STEREO_SPREAD;
-    const CF_TUNING_L8: usize = 1617;
-    const CF_TUNING_R8: usize = 1617 + Reverb::STEREO_SPREAD;
-    const APF_TUNING_L1: usize = 556;
-    const APF_TUNING_R1: usize = 556 + Reverb::STEREO_SPREAD;
-    const APF_TUNING_L2: usize = 441;
-    const APF_TUNING_R2: usize = 441 + Reverb::STEREO_SPREAD;
-    const APF_TUNING_L3: usize = 341;
-    const APF_TUNING_R3: usize = 341 + Reverb::STEREO_SPREAD;
-    const APF_TUNING_L4: usize = 225;
-    const APF_TUNING_R4: usize = 225 + Reverb::STEREO_SPREAD;
-
-    pub(crate) fn new(sample_rate: i32) -> Self {
-        let left_combfilters: Vec<CombFilter> = vec![
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L1)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L2)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L3)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L4)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L5)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L6)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L7)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_L8)),
-        ];
-
-        let right_combfilters: Vec<CombFilter> = vec![
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R1)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R2)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R3)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R4)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R5)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R6)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R7)),
-            CombFilter::new(Reverb::scale_tuning(sample_rate, Reverb::CF_TUNING_R8)),
-        ];
-
-        let mut left_allpassfilters: Vec<AllPassFilter> = vec![
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_L1)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_L2)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_L3)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_L4)),
-        ];
-
-        let mut right_allpassfilters: Vec<AllPassFilter> = vec![
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_R1)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_R2)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_R3)),
-            AllPassFilter::new(Reverb::scale_tuning(sample_rate, Reverb::APF_TUNING_R4)),
-        ];
-
-        for apf in left_allpassfilters.iter_mut() {
-            apf.set_feedback(0.5_f32);
-        }
-
-        for apf in right_allpassfilters.iter_mut() {
-            apf.set_feedback(0.5_f32);
-        }
-
-        let mut reverb = Reverb {
-            left_combfilters,
-            right_combfilters,
-            left_allpassfilters,
-            right_allpassfilters,
-            gain: 0_f32,
-            room_size: 0_f32,
-            room_size1: 0_f32,
-            damp: 0_f32,
-            damp1: 0_f32,
-            wet: 0_f32,
-            wet1: 0_f32,
-            wet2: 0_f32,
-            width: 0_f32,
-        };
-
-        reverb.set_wet(Reverb::INITIAL_WET);
-        reverb.set_room_size(Reverb::INITIAL_ROOM);
-        reverb.set_damp(Reverb::INITIAL_DAMP);
-        reverb.set_width(Reverb::INITIAL_WIDTH);
-
-        reverb
-    }
-
-    pub fn mute(&mut self) {
-        for cf in self.left_combfilters.iter_mut() {
-            cf.mute();
-        }
-
-        for cf in self.right_combfilters.iter_mut() {
-            cf.mute();
-        }
-
-        for apf in self.left_allpassfilters.iter_mut() {
-            apf.mute();
-        }
-
-        for apf in self.right_allpassfilters.iter_mut() {
-            apf.mute();
-        }
-    }
-
-    fn scale_tuning(sample_rate: i32, tuning: usize) -> usize {
-        ((sample_rate as f64) / 44100_f64 * (tuning as f64)).round() as usize
-    }
-
-    pub(crate) fn process(
-        &mut self,
-        input: &[f32],
-        output_left: &mut [f32],
-        output_right: &mut [f32],
-    ) {
-        let input_length = input.len();
-        let output_left_length = output_left.len();
-        let output_right_length = output_right.len();
-
-        for lsample in output_left.iter_mut().take(output_left_length) {
-            *lsample = 0_f32;
-        }
-        for rsample in output_right.iter_mut().take(output_right_length) {
-            *rsample = 0_f32;
-        }
-
-        for cf in self.left_combfilters.iter_mut() {
-            cf.process(input, output_left);
-        }
-
-        for apf in self.left_allpassfilters.iter_mut() {
-            apf.process(output_left);
-        }
-
-        for cf in self.right_combfilters.iter_mut() {
-            cf.process(input, output_right);
-        }
-
-        for apf in self.right_allpassfilters.iter_mut() {
-            apf.process(output_right);
-        }
-
-        // With the default settings, we can skip this part.
-        if 1_f32 - self.wet1 > 1.0E-3_f32 || self.wet2 > 1.0E-3_f32 {
-            for t in 0..input_length {
-                let left = output_left[t];
-                let right = output_right[t];
-                output_left[t] = left * self.wet1 + right * self.wet2;
-                output_right[t] = right * self.wet1 + left * self.wet2;
-            }
-        }
-    }
-
-    fn update(&mut self) {
-        self.wet1 = self.wet * (self.width / 2_f32 + 0.5_f32);
-        self.wet2 = self.wet * ((1_f32 - self.width) / 2_f32);
-
-        self.room_size1 = self.room_size;
-        self.damp1 = self.damp;
-        self.gain = Reverb::FIXED_GAIN;
-
-        for cf in self.left_combfilters.iter_mut() {
-            cf.set_feedback(self.room_size1);
-            cf.set_damp(self.damp1);
-        }
-
-        for cf in self.right_combfilters.iter_mut() {
-            cf.set_feedback(self.room_size1);
-            cf.set_damp(self.damp1);
-        }
-    }
-
-    pub fn get_input_gain(&self) -> f32 {
-        self.gain
-    }
-
-    fn set_room_size(&mut self, value: f32) {
-        self.room_size = (value * Reverb::SCALE_ROOM) + Reverb::OFFSET_ROOM;
-        self.update();
-    }
-
-    fn set_damp(&mut self, value: f32) {
-        self.damp = value * Reverb::SCALE_DAMP;
-        self.update();
-    }
-
-    fn set_wet(&mut self, value: f32) {
-        self.wet = value * Reverb::SCALE_WET;
-        self.update();
-    }
-
-    fn set_width(&mut self, value: f32) {
-        self.width = value;
-        self.update();
-    }
-}
-
-struct CombFilter {
-    buffer: Vec<f32>,
-
-    buffer_index: usize,
-    filter_store: f32,
-
-    feedback: f32,
-    damp1: f32,
-    damp2: f32,
-}
-
-impl CombFilter {
-    fn new(buffer_size: usize) -> Self {
-        Self {
-            buffer: vec![0_f32; buffer_size],
-            buffer_index: 0,
-            filter_store: 0_f32,
-            feedback: 0_f32,
-            damp1: 0_f32,
-            damp2: 0_f32,
-        }
-    }
-
-    fn mute(&mut self) {
-        let buffer_length = self.buffer.len();
-        for i in 0..buffer_length {
-            self.buffer[i] = 0_f32;
-        }
-
-        self.filter_store = 0_f32;
-    }
-
-    fn process(&mut self, input_block: &[f32], output_block: &mut [f32]) {
-        let buffer_length = self.buffer.len();
-        let output_block_length = output_block.len();
-
-        let mut block_index: usize = 0;
-        while block_index < output_block_length {
-            if self.buffer_index == buffer_length {
-                self.buffer_index = 0;
-            }
-
-            let src_rem = buffer_length - self.buffer_index;
-            let dst_rem = output_block_length - block_index;
-            let rem = cmp::min(src_rem, dst_rem);
-
-            for t in 0..rem {
-                let block_pos = block_index + t;
-                let buffer_pos = self.buffer_index + t;
-
-                let input = input_block[block_pos];
-
-                // The following ifs are to avoid performance problem due to denormalized number.
-                // The original implementation uses unsafe cast to detect denormalized number.
-                // I tried to reproduce the original implementation using Unsafe.As,
-                // but the simple Math.Abs version was faster according to some benchmarks.
-
-                let mut output = self.buffer[buffer_pos];
-                if output.abs() < 1.0E-6_f32 {
-                    output = 0_f32;
-                }
-
-                self.filter_store = (output * self.damp2) + (self.filter_store * self.damp1);
-                if self.filter_store.abs() < 1.0E-6_f32 {
-                    self.filter_store = 0_f32;
-                }
-
-                self.buffer[buffer_pos] = input + (self.filter_store * self.feedback);
-                output_block[block_pos] += output;
-            }
-
-            self.buffer_index += rem;
-            block_index += rem;
-        }
-    }
-
-    const fn set_feedback(&mut self, value: f32) {
-        self.feedback = value;
-    }
-
-    const fn set_damp(&mut self, value: f32) {
-        self.damp1 = value;
-        self.damp2 = 1_f32 - value;
-    }
-}
-
-struct AllPassFilter {
-    buffer: Vec<f32>,
-
-    buffer_index: usize,
-
-    feedback: f32,
-}
-
-impl AllPassFilter {
-    fn new(buffer_size: usize) -> Self {
-        Self {
-            buffer: vec![0_f32; buffer_size],
-            buffer_index: 0,
-            feedback: 0_f32,
-        }
-    }
-
-    fn mute(&mut self) {
-        let buffer_length = self.buffer.len();
-        for i in 0..buffer_length {
-            self.buffer[i] = 0_f32;
-        }
-    }
-
-    fn process(&mut self, block: &mut [f32]) {
-        let buffer_length = self.buffer.len();
-        let block_length = block.len();
-
-        let mut block_index: usize = 0;
-        while block_index < block_length {
-            if self.buffer_index == buffer_length {
-                self.buffer_index = 0;
-            }
-
-            let src_rem = buffer_length - self.buffer_index;
-            let dst_rem = block_length - block_index;
-            let rem = cmp::min(src_rem, dst_rem);
-
-            for t in 0..rem {
-                let block_pos = block_index + t;
-                let buffer_pos = self.buffer_index + t;
-
-                let input = block[block_pos];
-
-                let mut bufout = self.buffer[buffer_pos];
-                if bufout.abs() < 1.0E-6_f32 {
-                    bufout = 0_f32;
-                }
-
-                block[block_pos] = bufout - input;
-                self.buffer[buffer_pos] = input + (bufout * self.feedback);
-            }
-
-            self.buffer_index += rem;
-            block_index += rem;
-        }
-    }
-
-    fn set_feedback(&mut self, value: f32) {
-        self.feedback = value;
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/settings.rs b/src/synthesizer/src/synthesizer/settings.rs
deleted file mode 100644
index 27a7e6f..0000000
--- a/src/synthesizer/src/synthesizer/settings.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use crate::prelude::*;
-
-/// Specifies a set of parameters for synthesis.
-#[derive(Copy, Clone)]
-pub struct SynthesizerSettings {
-    /// The sample rate for synthesis.
-    pub sample_rate: i32,
-    /// The block size for rendering waveform.
-    pub block_size: usize,
-    /// The number of maximum polyphony.
-    pub maximum_polyphony: usize,
-    /// The value indicating whether reverb and chorus are enabled.
-    pub enable_reverb_and_chorus: bool,
-}
-
-impl SynthesizerSettings {
-    const DEFAULT_BLOCK_SIZE: usize = 64;
-    const DEFAULT_MAXIMUM_POLYPHONY: usize = 64;
-    const DEFAULT_ENABLE_REVERB_AND_CHORUS: bool = true;
-
-    /// Initializes a new instance of synthesizer settings.
-    ///
-    /// # Arguments
-    ///
-    /// * `sample_rate` - The sample rate for synthesis.
-    pub fn new(sample_rate: i32) -> Self {
-        Self {
-            sample_rate,
-            block_size: SynthesizerSettings::DEFAULT_BLOCK_SIZE,
-            maximum_polyphony: SynthesizerSettings::DEFAULT_MAXIMUM_POLYPHONY,
-            enable_reverb_and_chorus: SynthesizerSettings::DEFAULT_ENABLE_REVERB_AND_CHORUS,
-        }
-    }
-
-    pub(crate) fn validate(&self) -> Result<(), SynthesizerError> {
-        SynthesizerSettings::check_sample_rate(self.sample_rate)?;
-        SynthesizerSettings::check_block_size(self.block_size)?;
-        SynthesizerSettings::check_maximum_polyphony(self.maximum_polyphony)?;
-
-        Ok(())
-    }
-
-    fn check_sample_rate(value: i32) -> Result<(), SynthesizerError> {
-        if !(16_000..=192_000).contains(&value) {
-            return Err(SynthesizerError::SampleRateOutOfRange(value));
-        }
-
-        Ok(())
-    }
-
-    fn check_block_size(value: usize) -> Result<(), SynthesizerError> {
-        if !(8..=1024).contains(&value) {
-            return Err(SynthesizerError::BlockSizeOutOfRange(value));
-        }
-
-        Ok(())
-    }
-
-    fn check_maximum_polyphony(value: usize) -> Result<(), SynthesizerError> {
-        if !(8..=256).contains(&value) {
-            return Err(SynthesizerError::MaximumPolyphonyOutOfRange(value));
-        }
-
-        Ok(())
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/bi_quad_filter.rs b/src/synthesizer/src/synthesizer/voice/bi_quad_filter.rs
deleted file mode 100644
index db570b5..0000000
--- a/src/synthesizer/src/synthesizer/voice/bi_quad_filter.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use crate::prelude::*;
-use bevy_platform::prelude::*;
-
-pub(crate) struct BiQuadFilter {
-    sample_rate: i32,
-
-    active: bool,
-
-    a0: f32,
-    a1: f32,
-    a2: f32,
-    a3: f32,
-    a4: f32,
-
-    x1: f32,
-    x2: f32,
-    y1: f32,
-    y2: f32,
-}
-
-impl BiQuadFilter {
-    const RESONANCE_PEAK_OFFSET: f32 = 1_f32 - 1_f32 / core::f32::consts::SQRT_2;
-
-    pub(crate) fn new(settings: &SynthesizerSettings) -> Self {
-        Self {
-            sample_rate: settings.sample_rate,
-            active: false,
-            a0: 0_f32,
-            a1: 0_f32,
-            a2: 0_f32,
-            a3: 0_f32,
-            a4: 0_f32,
-            x1: 0_f32,
-            x2: 0_f32,
-            y1: 0_f32,
-            y2: 0_f32,
-        }
-    }
-
-    pub(crate) fn clear_buffer(&mut self) {
-        self.x1 = 0_f32;
-        self.x2 = 0_f32;
-        self.y1 = 0_f32;
-        self.y2 = 0_f32;
-    }
-
-    pub(crate) fn set_low_pass_filter(&mut self, cutoff_frequency: f32, resonance: f32) {
-        if cutoff_frequency < 0.499_f32 * self.sample_rate as f32 {
-            self.active = true;
-
-            // This equation gives the Q value which makes the desired resonance peak.
-            // The error of the resultant peak height is less than 3%.
-            let q = resonance
-                - BiQuadFilter::RESONANCE_PEAK_OFFSET / (1_f32 + 6_f32 * (resonance - 1_f32));
-
-            let w = 2_f32 * consts::PI * cutoff_frequency / self.sample_rate as f32;
-            let cosw = w.cos();
-            let alpha = w.sin() / (2_f32 * q);
-
-            let b0 = (1_f32 - cosw) / 2_f32;
-            let b1 = 1_f32 - cosw;
-            let b2 = (1_f32 - cosw) / 2_f32;
-            let a0 = 1_f32 + alpha;
-            let a1 = -2_f32 * cosw;
-            let a2 = 1_f32 - alpha;
-
-            self.set_coefficients(a0, a1, a2, b0, b1, b2);
-        } else {
-            self.active = false;
-        }
-    }
-
-    pub(crate) fn process(&mut self, block: &mut [f32]) {
-        let block_length = block.len();
-
-        if self.active {
-            for input in block.iter_mut().take(block_length) {
-                let output = self.a0 * *input + self.a1 * self.x1 + self.a2 * self.x2
-                    - self.a3 * self.y1
-                    - self.a4 * self.y2;
-
-                self.x2 = self.x1;
-                self.x1 = *input;
-                self.y2 = self.y1;
-                self.y1 = output;
-
-                *input = output;
-            }
-        } else {
-            self.x2 = block[block_length - 2];
-            self.x1 = block[block_length - 1];
-            self.y2 = self.x2;
-            self.y1 = self.x1;
-        }
-    }
-
-    fn set_coefficients(&mut self, a0: f32, a1: f32, a2: f32, b0: f32, b1: f32, b2: f32) {
-        self.a0 = b0 / a0;
-        self.a1 = b1 / a0;
-        self.a2 = b2 / a0;
-        self.a3 = a1 / a0;
-        self.a4 = a2 / a0;
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/envelope/common.rs b/src/synthesizer/src/synthesizer/voice/envelope/common.rs
deleted file mode 100644
index bc3f03e..0000000
--- a/src/synthesizer/src/synthesizer/voice/envelope/common.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-#![allow(dead_code)]
-use crate::prelude::*;
-
-use super::EnvelopeStage;
-
-// I think we can process volume and modulation
-// at the same time.
-pub struct CommonEnvelope {
-    pub sample_rate: i32,
-
-    pub attack_slope: f64,
-    pub decay_slope: f64,
-    pub release_slope: f64,
-
-    pub attack_start_time: f64,
-    pub hold_start_time: f64,
-    pub decay_start_time: f64,
-
-    pub sustain_level: f32,
-    pub release_level: f32,
-
-    pub processed_sample_count: usize,
-    pub stage: EnvelopeStage,
-    pub value: f32,
-}
-
-impl CommonEnvelope {
-    pub fn new(settings: &SynthesizerSettings) -> Self {
-        Self {
-            sample_rate: settings.sample_rate,
-            attack_slope: 0_f64,
-            decay_slope: 0_f64,
-            release_slope: 0_f64,
-            attack_start_time: 0_f64,
-            hold_start_time: 0_f64,
-            decay_start_time: 0_f64,
-            sustain_level: 0_f32,
-            release_level: 0_f32,
-            processed_sample_count: 0,
-            stage: EnvelopeStage::Delay,
-            value: 0_f32,
-        }
-    }
-
-    pub fn release(&mut self) {
-        self.stage = EnvelopeStage::Release;
-        self.release_level = self.value;
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/envelope/mod.rs b/src/synthesizer/src/synthesizer/voice/envelope/mod.rs
deleted file mode 100644
index 6d46f84..0000000
--- a/src/synthesizer/src/synthesizer/voice/envelope/mod.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-mod modulation;
-pub(super) use modulation::*;
-
-mod volume;
-pub(super) use volume::*;
-
-mod common;
-//use common::*;
-
-#[derive(Ord, PartialEq, PartialOrd, Eq, Clone, Copy, Debug)]
-pub enum EnvelopeStage {
-    Delay,
-    Attack,
-    Hold,
-    Decay,
-    Release,
-}
-
-impl EnvelopeStage {
-    pub fn next(self) -> EnvelopeStage {
-        use EnvelopeStage::*;
-        match self {
-            Delay => Attack,
-            Attack => Hold,
-            Hold => Decay,
-            Decay => Release,
-            Release => Release,
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/envelope/modulation.rs b/src/synthesizer/src/synthesizer/voice/envelope/modulation.rs
deleted file mode 100644
index 01f4af8..0000000
--- a/src/synthesizer/src/synthesizer/voice/envelope/modulation.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use crate::{prelude::*, synthesizer::RegionPair, utils};
-
-use super::EnvelopeStage;
-
-pub struct ModulationEnvelope {
-    sample_rate: i32,
-
-    attack_slope: f64,
-    decay_slope: f64,
-    release_slope: f64,
-
-    attack_start_time: f64,
-    hold_start_time: f64,
-    decay_start_time: f64,
-
-    decay_end_time: f64,
-    release_end_time: f64,
-
-    sustain_level: f32,
-    release_level: f32,
-
-    processed_sample_count: usize,
-    stage: EnvelopeStage,
-    value: f32,
-}
-
-impl ModulationEnvelope {
-    pub fn new(settings: &SynthesizerSettings, region: &RegionPair, key: u8, velocity: u8) -> Self {
-        // According to the implementation of TinySoundFont, the attack time should be adjusted by the velocity.
-        let delay = region.get_delay_modulation_envelope();
-        let attack = region.get_attack_modulation_envelope() * ((145 - velocity) as f32 / 144_f32);
-        let hold = region.get_hold_modulation_envelope()
-            * utils::key_number_to_multiplying_factor(
-                region.get_key_number_to_modulation_envelope_hold(),
-                key,
-            );
-        let decay = region.get_decay_modulation_envelope()
-            * utils::key_number_to_multiplying_factor(
-                region.get_key_number_to_modulation_envelope_decay(),
-                key,
-            );
-        let sustain = 1_f32 - region.get_sustain_modulation_envelope() / 100_f32;
-        let release = region.get_release_modulation_envelope();
-        let attack_slope = 1_f64 / attack as f64;
-        let decay_slope = 1_f64 / decay as f64;
-        let release_slope = 1_f64 / release as f64;
-
-        let attack_start_time = delay as f64;
-        let hold_start_time = attack_start_time + attack as f64;
-        let decay_start_time = hold_start_time + hold as f64;
-
-        let decay_end_time = decay_start_time + decay as f64;
-        let release_end_time = release as f64;
-
-        let sustain_level = sustain.clamp(0., 1.);
-
-        let release_level = 0_f32;
-
-        let processed_sample_count = 0;
-        let stage = EnvelopeStage::Delay;
-        let value = 0_f32;
-        let mut new = Self {
-            sample_rate: settings.sample_rate,
-            attack_slope,
-            decay_slope,
-            release_slope,
-            attack_start_time,
-            hold_start_time,
-            decay_start_time,
-            decay_end_time,
-            release_end_time,
-            sustain_level,
-            release_level,
-            processed_sample_count,
-            stage,
-            value,
-        };
-
-        new.process(0);
-        new
-    }
-
-    pub fn release(&mut self) {
-        self.stage = EnvelopeStage::Release;
-        self.release_end_time += self.processed_sample_count as f64 / self.sample_rate as f64;
-        self.release_level = self.value;
-    }
-
-    pub fn process(&mut self, sample_count: usize) -> Option<f32> {
-        self.processed_sample_count += sample_count;
-
-        let current_time = self.processed_sample_count as f64 / self.sample_rate as f64;
-
-        while self.stage <= EnvelopeStage::Hold {
-            let end_time = match self.stage {
-                EnvelopeStage::Delay => self.attack_start_time,
-                EnvelopeStage::Attack => self.hold_start_time,
-                EnvelopeStage::Hold => self.decay_start_time,
-                _ => panic!("Invalid envelope stage."),
-            };
-
-            if current_time < end_time {
-                break;
-            } else {
-                self.stage = self.stage.next();
-            }
-        }
-        match self.stage {
-            EnvelopeStage::Delay => Some(0.),
-            EnvelopeStage::Attack => {
-                Some((self.attack_slope * (current_time - self.attack_start_time)) as f32)
-            }
-            EnvelopeStage::Hold => Some(1.),
-            EnvelopeStage::Decay => {
-                let val = ((self.decay_slope * (self.decay_end_time - current_time)) as f32)
-                    .max(self.sustain_level);
-
-                (val > utils::NON_AUDIBLE).then_some(val)
-            }
-            EnvelopeStage::Release => {
-                let val = ((self.release_level as f64
-                    * self.release_slope
-                    * (self.release_end_time - current_time)) as f32)
-                    .max(0.);
-
-                (val > utils::NON_AUDIBLE).then_some(val)
-            }
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/envelope/volume.rs b/src/synthesizer/src/synthesizer/voice/envelope/volume.rs
deleted file mode 100644
index 120fbdf..0000000
--- a/src/synthesizer/src/synthesizer/voice/envelope/volume.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use crate::{prelude::*, synthesizer::RegionPair, utils};
-
-use super::EnvelopeStage;
-
-pub struct VolumeEnvelope {
-    sample_rate: i32,
-
-    attack_slope: f64,
-    decay_slope: f64,
-    release_slope: f64,
-
-    attack_start_time: f64,
-    hold_start_time: f64,
-    decay_start_time: f64,
-
-    release_start_time: f64,
-
-    sustain_level: f32,
-    release_level: f32,
-
-    processed_sample_count: usize,
-    stage: EnvelopeStage,
-    value: f32,
-}
-
-impl VolumeEnvelope {
-    pub fn new(settings: &SynthesizerSettings, region: &RegionPair, key: u8) -> Self {
-        // If the release time is shorter than 10 ms, it will be clamped to 10 ms to avoid pop noise.
-        let delay = region.get_delay_volume_envelope();
-        let attack = region.get_attack_volume_envelope();
-        let hold = region.get_hold_volume_envelope()
-            * utils::key_number_to_multiplying_factor(
-                region.get_key_number_to_volume_envelope_hold(),
-                key,
-            );
-        let decay = region.get_decay_volume_envelope()
-            * utils::key_number_to_multiplying_factor(
-                region.get_key_number_to_volume_envelope_decay(),
-                key,
-            );
-        let sustain = utils::decibels_to_linear(-region.get_sustain_volume_envelope());
-        let release = region.get_release_volume_envelope().max(0.01_f32);
-
-        let attack_slope = 1_f64 / attack as f64;
-        let decay_slope = -9.226_f64 / decay as f64;
-        let release_slope = -9.226_f64 / release as f64;
-
-        let attack_start_time = delay as f64;
-        let hold_start_time = attack_start_time + attack as f64;
-        let decay_start_time = hold_start_time + hold as f64;
-        let release_start_time = 0_f64;
-
-        // saw this twice. wtf
-        let sustain_level = sustain.clamp(0., 1.);
-
-        let release_level = 0_f32;
-
-        let processed_sample_count = 0;
-        let stage = EnvelopeStage::Delay;
-        let value = 0_f32;
-        let mut new = Self {
-            sample_rate: settings.sample_rate,
-            release_slope,
-            sustain_level,
-            processed_sample_count,
-            stage,
-            value,
-            attack_slope,
-            decay_slope,
-            release_level,
-            attack_start_time,
-            hold_start_time,
-            decay_start_time,
-            release_start_time,
-        };
-
-        new.process(0);
-        new
-    }
-
-    pub fn release(&mut self) {
-        //TODO: make this algebraic
-        self.stage = EnvelopeStage::Release;
-        self.release_start_time = self.processed_sample_count as f64 / self.sample_rate as f64;
-        self.release_level = self.value;
-    }
-
-    pub fn process(&mut self, sample_count: usize) -> Option<f32> {
-        self.processed_sample_count += sample_count;
-
-        let current_time = self.processed_sample_count as f64 / self.sample_rate as f64;
-
-        // interesting...
-        //
-        // Maybe we can refactor this to not loop
-        while self.stage <= EnvelopeStage::Hold {
-            let end_time = match self.stage {
-                EnvelopeStage::Delay => self.attack_start_time,
-                EnvelopeStage::Attack => self.hold_start_time,
-                EnvelopeStage::Hold => self.decay_start_time,
-                _ => panic!("Invalid envelope stage."),
-            };
-
-            if current_time < end_time {
-                break;
-            } else {
-                self.stage = self.stage.next();
-            }
-        }
-        match self.stage {
-            EnvelopeStage::Delay => Some(0.),
-            EnvelopeStage::Attack => {
-                Some((self.attack_slope * (current_time - self.attack_start_time)) as f32)
-            }
-            EnvelopeStage::Hold => Some(1_f32),
-            EnvelopeStage::Decay => {
-                let val =
-                    (utils::exp_cutoff(self.decay_slope * (current_time - self.decay_start_time))
-                        as f32)
-                        .max(self.sustain_level);
-
-                (val > utils::NON_AUDIBLE).then_some(val)
-            }
-            EnvelopeStage::Release => {
-                let val = (self.release_level as f64
-                    * utils::exp_cutoff(
-                        self.release_slope * (current_time - self.release_start_time),
-                    )) as f32;
-                (val > utils::NON_AUDIBLE).then_some(val)
-            }
-        }
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/mod.rs b/src/synthesizer/src/synthesizer/voice/mod.rs
deleted file mode 100644
index 3824055..0000000
--- a/src/synthesizer/src/synthesizer/voice/mod.rs
+++ /dev/null
@@ -1,330 +0,0 @@
-use bevy_platform::prelude::*;
-mod envelope;
-use envelope::*;
-mod region;
-pub(super) use region::*;
-
-mod oscillator;
-use oscillator::*;
-
-mod bi_quad_filter;
-use bi_quad_filter::*;
-
-use crate::{prelude::*, utils};
-
-use super::Channel;
-
-pub(crate) struct Voice {
-    block_size: usize,
-
-    vol_env: VolumeEnvelope,
-    mod_env: ModulationEnvelope,
-
-    vib_lfo: Lfo,
-    mod_lfo: Lfo,
-
-    oscillator: Oscillator,
-    filter: BiQuadFilter,
-
-    pub(crate) block: Vec<f32>,
-
-    // A sudden change in the mix gain will cause pop noise.
-    // To avoid this, we save the mix gain of the previous block,
-    // and smooth out the gain if the gap between the current and previous gain is too large.
-    // The actual smoothing process is done in the WriteBlock method of the Synthesizer class.
-    pub(crate) previous_mix_gain_left: f32,
-    pub(crate) previous_mix_gain_right: f32,
-    pub(crate) current_mix_gain_left: f32,
-    pub(crate) current_mix_gain_right: f32,
-
-    pub(crate) previous_reverb_send: f32,
-    pub(crate) previous_chorus_send: f32,
-    pub(crate) current_reverb_send: f32,
-    pub(crate) current_chorus_send: f32,
-
-    pub(crate) exclusive_class: i32,
-    pub(crate) channel: u8,
-    pub(crate) key: u8,
-
-    note_gain: f32,
-
-    cutoff: f32,
-    resonance: f32,
-
-    vib_lfo_to_pitch: f32,
-    mod_lfo_to_pitch: f32,
-    mod_env_to_pitch: f32,
-
-    mod_lfo_to_cutoff: i32,
-    mod_env_to_cutoff: i32,
-    dynamic_cutoff: bool,
-
-    mod_lfo_to_volume: f32,
-    dynamic_volume: bool,
-
-    instrument_pan: f32,
-    instrument_reverb: f32,
-    instrument_chorus: f32,
-
-    // Some instruments require fast cutoff change, which can cause pop noise.
-    // This is used to smooth out the cutoff frequency.
-    smoothed_cutoff: f32,
-
-    voice_state: VoiceState,
-    pub(crate) voice_length: usize,
-    min_voice_length: usize,
-}
-
-impl Voice {
-    pub(crate) fn new(
-        settings: &SynthesizerSettings,
-        region: &RegionPair,
-        channel: u8,
-        key: u8,
-        velocity: u8,
-    ) -> Self {
-        // this is used elsewhere...really thinking we should
-        // just use the region
-        let exclusive_class = region.get_exclusive_class();
-
-        let note_gain = if velocity > 0 {
-            // According to the Polyphone's implementation, the initial attenuation should be reduced to 40%.
-            // I'm not sure why, but this indeed improves the loudness variability.
-            let sample_attenuation = 0.4_f32 * region.get_initial_attenuation();
-            let filter_attenuation = 0.5_f32 * region.get_initial_filter_q();
-            let decibels = 2_f32 * utils::linear_to_decibels(velocity as f32 / 127_f32)
-                - sample_attenuation
-                - filter_attenuation;
-            utils::decibels_to_linear(decibels)
-        } else {
-            0_f32
-        };
-
-        let cutoff = region.get_initial_filter_cutoff_frequency();
-        let resonance = utils::decibels_to_linear(region.get_initial_filter_q());
-
-        let vib_lfo_to_pitch = 0.01_f32 * region.get_vibrato_lfo_to_pitch() as f32;
-        let mod_lfo_to_pitch = 0.01_f32 * region.get_modulation_lfo_to_pitch() as f32;
-        let mod_env_to_pitch = 0.01_f32 * region.get_modulation_envelope_to_pitch() as f32;
-
-        let mod_lfo_to_cutoff = region.get_modulation_lfo_to_filter_cutoff_frequency();
-        let mod_env_to_cutoff = region.get_modulation_envelope_to_filter_cutoff_frequency();
-        //todo: derivable and cheap.
-        let dynamic_cutoff = mod_lfo_to_cutoff != 0 || mod_env_to_cutoff != 0;
-
-        let mod_lfo_to_volume = region.get_modulation_lfo_to_volume();
-        let dynamic_volume = mod_lfo_to_volume > 0.05_f32;
-
-        let instrument_pan = region.get_pan().clamp(-50., 50.);
-
-        let instrument_reverb = 0.01_f32 * region.get_reverb_effects_send();
-        let instrument_chorus = 0.01_f32 * region.get_chorus_effects_send();
-
-        let vol_env = VolumeEnvelope::new(settings, region, key);
-        let mod_env = ModulationEnvelope::new(settings, region, key, velocity);
-
-        let vib_lfo = Lfo::new(
-            settings,
-            region.get_delay_vibrato_lfo(),
-            region.get_frequency_vibrato_lfo(),
-        );
-        let mod_lfo = Lfo::new(
-            settings,
-            region.get_delay_modulation_lfo(),
-            region.get_frequency_modulation_lfo(),
-        );
-
-        let oscillator = Oscillator::new(settings, region);
-
-        let mut filter = BiQuadFilter::new(settings);
-        filter.clear_buffer();
-        filter.set_low_pass_filter(cutoff, resonance);
-
-        let smoothed_cutoff = cutoff;
-
-        let voice_state = VoiceState::Playing;
-        //???
-        let voice_length = 0;
-
-        //???
-        let min_voice_length = (settings.sample_rate / 500) as usize;
-        Self {
-            block_size: settings.block_size,
-            vol_env,
-            mod_env,
-            vib_lfo,
-            mod_lfo,
-            oscillator,
-            filter,
-            block: vec![0_f32; settings.block_size],
-            previous_mix_gain_left: 0_f32,
-            previous_mix_gain_right: 0_f32,
-            current_mix_gain_left: 0_f32,
-            current_mix_gain_right: 0_f32,
-            previous_reverb_send: 0_f32,
-            previous_chorus_send: 0_f32,
-            current_reverb_send: 0_f32,
-            current_chorus_send: 0_f32,
-            exclusive_class,
-            channel,
-            key,
-            note_gain,
-            cutoff,
-            resonance,
-            vib_lfo_to_pitch,
-            mod_lfo_to_pitch,
-            mod_env_to_pitch,
-            mod_lfo_to_cutoff,
-            mod_env_to_cutoff,
-            dynamic_cutoff,
-            mod_lfo_to_volume,
-            dynamic_volume,
-            instrument_pan,
-            instrument_reverb,
-            instrument_chorus,
-            smoothed_cutoff,
-            voice_state,
-            voice_length,
-            min_voice_length,
-        }
-    }
-
-    pub(crate) fn end(&mut self) {
-        if self.voice_state == VoiceState::Playing {
-            self.voice_state = VoiceState::ReleaseRequested;
-        }
-    }
-
-    // /// Note stops immediately without a release sound.
-    // ///
-    // /// End is *supposed* to begin playing a release sound. this is the
-    // /// evil twin.
-    // ///
-    // /// This also means it will drop on the next process call.
-    // pub(crate) fn kill(&mut self) {
-    //     self.note_gain = 0_f32;
-    // }
-
-    /// this is only called in one place: render_block. If I return false,
-    /// I will die.
-    ///
-    /// When do I die?
-    ///
-    /// 1. if my note_gain is less than NON_audible
-    /// 2. if my volume envelope determines I am no longer audible
-    /// 3. mod env is just hanging around, so it's definitely not supposed to
-    ///    return a bool
-    ///
-    pub(crate) fn process(&mut self, data: &[i16], channels: &[Channel]) -> bool {
-        if self.note_gain < utils::NON_AUDIBLE {
-            return false;
-        }
-
-        let channel_info = &channels[self.channel as usize];
-
-        self.release_if_necessary(channel_info);
-
-        let Some(vol_env) = self.vol_env.process(self.block_size) else {
-            return false;
-        };
-
-        let Some(mod_env) = self.mod_env.process(self.block_size) else {
-            return false;
-        };
-        let vib_lfo = self.vib_lfo.process();
-        let mod_lfo = self.mod_lfo.process();
-
-        let vib_pitch_change =
-            (0.01_f32 * channel_info.get_modulation() + self.vib_lfo_to_pitch) * vib_lfo;
-        let mod_pitch_change = self.mod_lfo_to_pitch * mod_lfo + self.mod_env_to_pitch * mod_env;
-        let channel_pitch_change = channel_info.get_tune() + channel_info.get_pitch_bend();
-        let pitch = self.key as f32 + vib_pitch_change + mod_pitch_change + channel_pitch_change;
-        if !self.oscillator.process(data, &mut self.block[..], pitch) {
-            return false;
-        }
-
-        if self.dynamic_cutoff {
-            let cents =
-                self.mod_lfo_to_cutoff as f32 * mod_lfo + self.mod_env_to_cutoff as f32 * mod_env;
-            let factor = utils::cents_to_multiplying_factor(cents);
-            let new_cutoff = factor * self.cutoff;
-
-            // The cutoff change is limited within x0.5 and x2 to reduce pop noise.
-            let lower_limit = 0.5_f32 * self.smoothed_cutoff;
-            let upper_limit = 2_f32 * self.smoothed_cutoff;
-
-            self.smoothed_cutoff = new_cutoff.clamp(lower_limit, upper_limit);
-
-            self.filter
-                .set_low_pass_filter(self.smoothed_cutoff, self.resonance);
-        }
-        self.filter.process(&mut self.block[..]);
-
-        self.previous_mix_gain_left = self.current_mix_gain_left;
-        self.previous_mix_gain_right = self.current_mix_gain_right;
-        self.previous_reverb_send = self.current_reverb_send;
-        self.previous_chorus_send = self.current_chorus_send;
-
-        // According to the GM spec, the following value should be squared.
-        let ve = channel_info.get_volume() * channel_info.get_expression();
-        let channel_gain = ve * ve;
-
-        let mut mix_gain = self.note_gain * channel_gain * vol_env;
-        if self.dynamic_volume {
-            let decibels = self.mod_lfo_to_volume * mod_lfo;
-            mix_gain *= utils::decibels_to_linear(decibels);
-        }
-
-        let angle =
-            (consts::PI / 200_f32) * (channel_info.get_pan() + self.instrument_pan + 50_f32);
-        if angle <= 0_f32 {
-            self.current_mix_gain_left = mix_gain;
-            self.current_mix_gain_right = 0_f32;
-        } else if angle >= utils::HALF_PI {
-            self.current_mix_gain_left = 0_f32;
-            self.current_mix_gain_right = mix_gain;
-        } else {
-            self.current_mix_gain_left = mix_gain * angle.cos();
-            self.current_mix_gain_right = mix_gain * angle.sin();
-        }
-
-        self.current_reverb_send =
-            (channel_info.get_reverb_send() + self.instrument_reverb).clamp(0., 1.);
-
-        self.current_chorus_send =
-            (channel_info.get_chorus_send() + self.instrument_chorus).clamp(0., 1.);
-
-        if self.voice_length == 0 {
-            self.previous_mix_gain_left = self.current_mix_gain_left;
-            self.previous_mix_gain_right = self.current_mix_gain_right;
-            self.previous_reverb_send = self.current_reverb_send;
-            self.previous_chorus_send = self.current_chorus_send;
-        }
-
-        self.voice_length += self.block_size;
-
-        true
-    }
-
-    fn release_if_necessary(&mut self, channel_info: &Channel) {
-        if self.voice_length < self.min_voice_length {
-            return;
-        }
-
-        if self.voice_state == VoiceState::ReleaseRequested && !channel_info.get_hold_pedal() {
-            self.vol_env.release();
-            self.mod_env.release();
-            self.oscillator.release();
-
-            self.voice_state = VoiceState::Released;
-        }
-    }
-}
-
-#[allow(unused)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum VoiceState {
-    Playing,
-    ReleaseRequested,
-    Released,
-}
diff --git a/src/synthesizer/src/synthesizer/voice/oscillator.rs b/src/synthesizer/src/synthesizer/voice/oscillator.rs
deleted file mode 100644
index 511fe0e..0000000
--- a/src/synthesizer/src/synthesizer/voice/oscillator.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-use super::RegionPair;
-
-use crate::prelude::*;
-
-// In this class, fixed-point numbers are used for speed-up.
-// A fixed-point number is expressed by Int64, whose lower 24 bits represent the fraction part,
-// and the rest represent the integer part.
-// For clarity, fixed-point number variables have a suffix "_fp".
-
-#[non_exhaustive]
-pub(crate) struct Oscillator {
-    loop_mode: LoopMode,
-    end: i32,
-    start_loop: i32,
-    end_loop: i32,
-    root_key: i32,
-
-    tune: f32,
-    pitch_change_scale: f32,
-    sample_rate_ratio: f32,
-
-    looping: bool,
-
-    position_fp: i64,
-}
-
-impl Oscillator {
-    const FRAC_BITS: i32 = 24;
-    const FRAC_UNIT: i64 = 1_i64 << Oscillator::FRAC_BITS;
-    const FP_TO_SAMPLE: f32 = 1_f32 / (32768 * Oscillator::FRAC_UNIT) as f32;
-
-    pub(crate) fn new(settings: &SynthesizerSettings, region: &RegionPair) -> Self {
-        let sample_rate = region.instrument.sample_sample_rate;
-        let loop_mode = region.get_sample_modes();
-        let start = region.get_sample_start();
-        let end = region.get_sample_end();
-        let start_loop = region.get_sample_start_loop();
-        let end_loop = region.get_sample_end_loop();
-        let root_key = region.get_root_key();
-        let coarse_tune = region.get_coarse_tune();
-        let fine_tune = region.get_fine_tune();
-        let scale_tuning = region.get_scale_tuning();
-
-        let tune = coarse_tune as f32 + 0.01_f32 * fine_tune as f32;
-        let pitch_change_scale = 0.01_f32 * scale_tuning as f32;
-        let sample_rate_ratio = sample_rate as f32 / settings.sample_rate as f32;
-        let looping = loop_mode != LoopMode::NoLoop;
-        let position_fp = (start as i64) << Oscillator::FRAC_BITS;
-
-        Self {
-            loop_mode,
-            end,
-            start_loop,
-            end_loop,
-            root_key,
-            tune,
-            pitch_change_scale,
-            sample_rate_ratio,
-            looping,
-            position_fp,
-        }
-    }
-
-    pub(crate) fn release(&mut self) {
-        if self.loop_mode == LoopMode::LoopUntilNoteOff {
-            self.looping = false;
-        }
-    }
-
-    pub(crate) fn process(&mut self, data: &[i16], block: &mut [f32], pitch: f32) -> bool {
-        let pitch_change = self.pitch_change_scale * (pitch - self.root_key as f32) + self.tune;
-        let pitch_ratio = self.sample_rate_ratio * 2_f32.powf(pitch_change / 12_f32);
-        self.fill_block(data, block, pitch_ratio as f64)
-    }
-
-    fn fill_block(&mut self, data: &[i16], block: &mut [f32], pitch_ratio: f64) -> bool {
-        let pitch_ratio_fp = (Oscillator::FRAC_UNIT as f64 * pitch_ratio) as i64;
-
-        if self.looping {
-            self.fill_block_continuous(data, block, pitch_ratio_fp)
-        } else {
-            self.fill_block_no_loop(data, block, pitch_ratio_fp)
-        }
-    }
-
-    fn fill_block_no_loop(&mut self, data: &[i16], block: &mut [f32], pitch_ratio_fp: i64) -> bool {
-        for t in 0..block.len() {
-            let index = (self.position_fp >> Oscillator::FRAC_BITS) as usize;
-            if index >= self.end as usize {
-                if t > 0 {
-                    let len = block.len();
-                    block[t..len].fill(0_f32);
-                    return true;
-                } else {
-                    return false;
-                }
-            }
-
-            let x1 = data[index] as i64;
-            let x2 = data[index + 1] as i64;
-            let a_fp = self.position_fp & (Oscillator::FRAC_UNIT - 1);
-            block[t] = Oscillator::FP_TO_SAMPLE
-                * ((x1 << Oscillator::FRAC_BITS) + a_fp * (x2 - x1)) as f32;
-
-            self.position_fp += pitch_ratio_fp;
-        }
-
-        true
-    }
-
-    fn fill_block_continuous(
-        &mut self,
-        data: &[i16],
-        block: &mut [f32],
-        pitch_ratio_fp: i64,
-    ) -> bool {
-        let end_loop_fp = (self.end_loop as i64) << Oscillator::FRAC_BITS;
-        let loop_length = (self.end_loop - self.start_loop) as i64;
-        let loop_length_fp = loop_length << Oscillator::FRAC_BITS;
-
-        for sample in block.iter_mut() {
-            if self.position_fp >= end_loop_fp {
-                self.position_fp -= loop_length_fp;
-            }
-
-            let index1 = (self.position_fp >> Oscillator::FRAC_BITS) as usize;
-            let mut index2 = index1 + 1;
-            if index2 >= self.end_loop as usize {
-                index2 -= loop_length as usize;
-            }
-
-            let x1 = data[index1] as i64;
-            let x2 = data[index2] as i64;
-            let a_fp = self.position_fp & (Oscillator::FRAC_UNIT - 1);
-            *sample = Oscillator::FP_TO_SAMPLE
-                * ((x1 << Oscillator::FRAC_BITS) + a_fp * (x2 - x1)) as f32;
-
-            self.position_fp += pitch_ratio_fp;
-        }
-
-        true
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/region/lfo.rs b/src/synthesizer/src/synthesizer/voice/region/lfo.rs
deleted file mode 100644
index 0d25dfb..0000000
--- a/src/synthesizer/src/synthesizer/voice/region/lfo.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use crate::prelude::*;
-
-#[non_exhaustive]
-pub struct Lfo {
-    sample_rate: i32,
-    block_size: usize,
-
-    active: bool,
-
-    delay: f64,
-    period: f64,
-
-    processed_sample_count: usize,
-    value: f32,
-}
-
-impl Lfo {
-    pub fn new(settings: &SynthesizerSettings, delay: f32, frequency: f32) -> Self {
-        let mut active = false;
-        let mut slf_delay = 0.;
-        let mut period = 0.;
-        if frequency > 1.0E-3_f32 {
-            active = true;
-            slf_delay = delay as f64;
-            period = 1.0_f64 / frequency as f64;
-        }
-        Self {
-            sample_rate: settings.sample_rate,
-            block_size: settings.block_size,
-            active,
-            delay: slf_delay,
-            period,
-            processed_sample_count: 0,
-            value: 0_f32,
-        }
-    }
-
-    pub fn process(&mut self) -> f32 {
-        if !self.active {
-            return self.value;
-        }
-
-        self.processed_sample_count += self.block_size;
-
-        let current_time = self.processed_sample_count as f64 / self.sample_rate as f64;
-
-        if current_time < self.delay {
-            self.value = 0_f32;
-        } else {
-            let phase = ((current_time - self.delay) % self.period) / self.period;
-            if phase < 0.25 {
-                self.value = (4_f64 * phase) as f32;
-            } else if phase < 0.75 {
-                self.value = (4_f64 * (0.5 - phase)) as f32;
-            } else {
-                self.value = (4_f64 * (phase - 1.0)) as f32;
-            }
-        }
-        self.value
-    }
-}
diff --git a/src/synthesizer/src/synthesizer/voice/region/mod.rs b/src/synthesizer/src/synthesizer/voice/region/mod.rs
deleted file mode 100644
index a16a4fd..0000000
--- a/src/synthesizer/src/synthesizer/voice/region/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod pair;
-pub use pair::*;
-mod lfo;
-pub use lfo::*;
diff --git a/src/synthesizer/src/synthesizer/voice/region/pair.rs b/src/synthesizer/src/synthesizer/voice/region/pair.rs
deleted file mode 100644
index cc95c4f..0000000
--- a/src/synthesizer/src/synthesizer/voice/region/pair.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use crate::{prelude::*, utils};
-
-pub struct RegionPair<'a> {
-    pub preset: &'a PresetRegion,
-    pub instrument: &'a InstrumentRegion,
-}
-
-impl<'a> RegionPair<'a> {
-    pub fn new(preset: &'a PresetRegion, instrument: &'a InstrumentRegion) -> Self {
-        Self { preset, instrument }
-    }
-
-    fn gs(&self, i: usize) -> i32 {
-        self.preset.gs[i] as i32 + self.instrument.gs[i] as i32
-    }
-
-    pub fn get_sample_start(&self) -> i32 {
-        self.instrument.get_sample_start()
-    }
-
-    pub fn get_sample_end(&self) -> i32 {
-        self.instrument.get_sample_end()
-    }
-
-    pub fn get_sample_start_loop(&self) -> i32 {
-        self.instrument.get_sample_start_loop()
-    }
-
-    pub fn get_sample_end_loop(&self) -> i32 {
-        self.instrument.get_sample_end_loop()
-    }
-
-    pub fn get_modulation_lfo_to_pitch(&self) -> i32 {
-        self.gs(GeneratorType::MODULATION_LFO_TO_PITCH as usize)
-    }
-
-    pub fn get_vibrato_lfo_to_pitch(&self) -> i32 {
-        self.gs(GeneratorType::VIBRATO_LFO_TO_PITCH as usize)
-    }
-
-    pub fn get_modulation_envelope_to_pitch(&self) -> i32 {
-        self.gs(GeneratorType::MODULATION_ENVELOPE_TO_PITCH as usize)
-    }
-
-    pub fn get_initial_filter_cutoff_frequency(&self) -> f32 {
-        utils::cents_to_hertz(
-            self.gs(GeneratorType::INITIAL_FILTER_CUTOFF_FREQUENCY as usize) as f32,
-        )
-    }
-
-    pub fn get_initial_filter_q(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::INITIAL_FILTER_Q as usize) as f32
-    }
-
-    pub fn get_modulation_lfo_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs(GeneratorType::MODULATION_LFO_TO_FILTER_CUTOFF_FREQUENCY as usize)
-    }
-
-    pub fn get_modulation_envelope_to_filter_cutoff_frequency(&self) -> i32 {
-        self.gs(GeneratorType::MODULATION_ENVELOPE_TO_FILTER_CUTOFF_FREQUENCY as usize)
-    }
-
-    pub fn get_modulation_lfo_to_volume(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::MODULATION_LFO_TO_VOLUME as usize) as f32
-    }
-
-    pub fn get_chorus_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::CHORUS_EFFECTS_SEND as usize) as f32
-    }
-
-    pub fn get_reverb_effects_send(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::REVERB_EFFECTS_SEND as usize) as f32
-    }
-
-    pub fn get_pan(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::PAN as usize) as f32
-    }
-
-    pub fn get_delay_modulation_lfo(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::DELAY_MODULATION_LFO as usize) as f32)
-    }
-
-    pub fn get_frequency_modulation_lfo(&self) -> f32 {
-        utils::cents_to_hertz(self.gs(GeneratorType::FREQUENCY_MODULATION_LFO as usize) as f32)
-    }
-
-    pub fn get_delay_vibrato_lfo(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::DELAY_VIBRATO_LFO as usize) as f32)
-    }
-
-    pub fn get_frequency_vibrato_lfo(&self) -> f32 {
-        utils::cents_to_hertz(self.gs(GeneratorType::FREQUENCY_VIBRATO_LFO as usize) as f32)
-    }
-
-    pub fn get_delay_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs(GeneratorType::DELAY_MODULATION_ENVELOPE as usize) as f32
-        )
-    }
-
-    pub fn get_attack_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs(GeneratorType::ATTACK_MODULATION_ENVELOPE as usize) as f32
-        )
-    }
-
-    pub fn get_hold_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::HOLD_MODULATION_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_decay_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs(GeneratorType::DECAY_MODULATION_ENVELOPE as usize) as f32
-        )
-    }
-
-    pub fn get_sustain_modulation_envelope(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::SUSTAIN_MODULATION_ENVELOPE as usize) as f32
-    }
-
-    pub fn get_release_modulation_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(
-            self.gs(GeneratorType::RELEASE_MODULATION_ENVELOPE as usize) as f32
-        )
-    }
-
-    pub fn get_key_number_to_modulation_envelope_hold(&self) -> i32 {
-        self.gs(GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_HOLD as usize)
-    }
-
-    pub fn get_key_number_to_modulation_envelope_decay(&self) -> i32 {
-        self.gs(GeneratorType::KEY_NUMBER_TO_MODULATION_ENVELOPE_DECAY as usize)
-    }
-
-    pub fn get_delay_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::DELAY_VOLUME_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_attack_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::ATTACK_VOLUME_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_hold_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::HOLD_VOLUME_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_decay_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::DECAY_VOLUME_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_sustain_volume_envelope(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::SUSTAIN_VOLUME_ENVELOPE as usize) as f32
-    }
-
-    pub fn get_release_volume_envelope(&self) -> f32 {
-        utils::timecents_to_seconds(self.gs(GeneratorType::RELEASE_VOLUME_ENVELOPE as usize) as f32)
-    }
-
-    pub fn get_key_number_to_volume_envelope_hold(&self) -> i32 {
-        self.gs(GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_HOLD as usize)
-    }
-
-    pub fn get_key_number_to_volume_envelope_decay(&self) -> i32 {
-        self.gs(GeneratorType::KEY_NUMBER_TO_VOLUME_ENVELOPE_DECAY as usize)
-    }
-
-    pub fn get_initial_attenuation(&self) -> f32 {
-        0.1_f32 * self.gs(GeneratorType::INITIAL_ATTENUATION as usize) as f32
-    }
-
-    pub fn get_coarse_tune(&self) -> i32 {
-        self.gs(GeneratorType::COARSE_TUNE as usize)
-    }
-
-    pub fn get_fine_tune(&self) -> i32 {
-        self.gs(GeneratorType::FINE_TUNE as usize) + self.instrument.sample_pitch_correction
-    }
-
-    pub fn get_sample_modes(&self) -> LoopMode {
-        self.instrument.get_sample_modes()
-    }
-
-    pub fn get_scale_tuning(&self) -> i32 {
-        self.gs(GeneratorType::SCALE_TUNING as usize)
-    }
-
-    pub fn get_exclusive_class(&self) -> i32 {
-        self.instrument.get_exclusive_class()
-    }
-
-    pub fn get_root_key(&self) -> i32 {
-        self.instrument.get_root_key()
-    }
-}
diff --git a/src/synthesizer/src/utils.rs b/src/synthesizer/src/utils.rs
deleted file mode 100644
index 4956f76..0000000
--- a/src/synthesizer/src/utils.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use bevy_platform::prelude::*;
-pub(crate) const HALF_PI: f32 = consts::PI / 2_f32;
-pub(crate) const NON_AUDIBLE: f32 = 1.0e-4_f32;
-pub(crate) const LOG_NON_AUDIBLE: f32 = -6.907_755_4_f32;
-
-pub(crate) fn timecents_to_seconds(x: f32) -> f32 {
-    2_f32.powf((1_f32 / 1200_f32) * x)
-}
-
-pub(crate) fn cents_to_hertz(x: f32) -> f32 {
-    8.176_f32 * 2_f32.powf((1_f32 / 1200_f32) * x)
-}
-
-pub(crate) fn cents_to_multiplying_factor(x: f32) -> f32 {
-    2_f32.powf((1_f32 / 1200_f32) * x)
-}
-
-pub(crate) fn decibels_to_linear(x: f32) -> f32 {
-    10_f32.powf(0.05_f32 * x)
-}
-
-pub(crate) fn linear_to_decibels(x: f32) -> f32 {
-    20_f32 * x.log10()
-}
-
-pub(crate) fn key_number_to_multiplying_factor(cents: i32, key: u8) -> f32 {
-    timecents_to_seconds((cents * (60 - key as i32)) as f32)
-}
-
-pub(crate) fn exp_cutoff(x: f64) -> f64 {
-    if x < LOG_NON_AUDIBLE as f64 {
-        0_f64
-    } else {
-        x.exp()
-    }
-}
diff --git a/src/utils.rs b/src/utils.rs
index bafb142..cedbdae 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -4,5 +4,4 @@ pub(crate) fn check_u7(byte: u8) -> Result<u8, ParseError> {
     (byte & 0b1000_0000 == 0)
         .then_some(byte)
         .ok_or(ParseError::InvalidDataByte(byte))
-    //.ok_or(io_error!(ErrorKind::InvalidData, "Leading bit found"))
 }
diff --git a/src/velocity.rs b/src/velocity.rs
index c396bdc..f53dc41 100644
--- a/src/velocity.rs
+++ b/src/velocity.rs
@@ -4,7 +4,7 @@ use core::fmt;
 /// Identifies the velocity of a key press, or a key unpress, or an aftertouch.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 #[cfg_attr(
-    feature = "bevy_resources",
+    feature = "bevy",
     derive(bevy::prelude::Reflect, bevy::prelude::Component)
 )]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]