From 7ee54e8333632db0110d592fef8d0b958825e514 Mon Sep 17 00:00:00 2001
From: BlackPhlox <theluja@gmail.com>
Date: Sun, 11 Jul 2021 20:27:48 +0200
Subject: [PATCH 1/3] Added midi msg remap and added test example for adsick

---
 examples/adsick_piano.rs | 275 +++++++++++++++++++++++++++++++++++++++
 examples/piano.rs        |  10 +-
 examples/simple.rs       |   9 +-
 src/lib.rs               |  19 ++-
 4 files changed, 299 insertions(+), 14 deletions(-)
 create mode 100644 examples/adsick_piano.rs

diff --git a/examples/adsick_piano.rs b/examples/adsick_piano.rs
new file mode 100644
index 0000000..0998053
--- /dev/null
+++ b/examples/adsick_piano.rs
@@ -0,0 +1,275 @@
+use bevy::{pbr::AmbientLight, prelude::*};
+use bevy_config_cam::ConfigCam;
+use bevy_midi::{Midi, MidiEvent, MidiSettings, translate};
+
+#[derive(Debug)]
+struct Key(String, f32);
+
+fn main() {
+    App::build()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 1.0 / 5.0f32,
+        })
+        .insert_resource(Msaa { samples: 4 })
+        .add_plugin(ConfigCam)
+        .add_plugin(Midi)
+        .insert_resource(MidiSettings { 
+            note_on: 156,
+            note_off: 140,
+            ..Default::default() 
+        })
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
+        .add_startup_system(setup_piano.system())
+        .add_system(rotator_system.system())
+        .add_system(midi_listener.system())
+        //.add_system(key_bow_system.system())
+        .run();
+}
+
+fn setup_piano(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let pos: Vec3 = Vec3::new(0., 0., 0.);
+
+    let black_key: Handle<Scene> = asset_server.load("models/black_key.gltf#Scene0");
+    let white_key_0: Handle<Scene> = asset_server.load("models/white_key_0.gltf#Scene0");
+    let white_key_1: Handle<Scene> = asset_server.load("models/white_key_1.gltf#Scene0");
+    let white_key_2: Handle<Scene> = asset_server.load("models/white_key_2.gltf#Scene0");
+
+    //Building the keyboard of every octave section
+    for i in 0..8 {
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("C{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_0.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.15 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("C#{}", i), 0.06))
+            .with_children(|cell| {
+                cell.spawn_scene(black_key.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.27 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("D{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_1.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.39 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("D#{}", i), 0.06))
+            .with_children(|cell| {
+                cell.spawn_scene(black_key.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.54 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("E{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_2.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.69 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("F{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_0.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.85 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("F#{}", i), 0.06))
+            .with_children(|cell| {
+                cell.spawn_scene(black_key.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.96 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("G{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_1.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.08 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("G#{}", i), 0.06))
+            .with_children(|cell| {
+                cell.spawn_scene(black_key.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.19 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("A{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_1.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.31 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("A#{}", i), 0.06))
+            .with_children(|cell| {
+                cell.spawn_scene(black_key.clone());
+            });
+
+        commands
+            .spawn_bundle((
+                Transform {
+                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.46 - (1.61 * i as f32)),
+                    scale: Vec3::new(10., 10., 10.),
+                    ..Default::default()
+                },
+                GlobalTransform::identity(),
+            ))
+            .insert(Key(format!("B{}", i), 0.))
+            .with_children(|cell| {
+                cell.spawn_scene(white_key_2.clone());
+            });
+    }
+}
+
+fn setup(mut commands: Commands) {
+    commands
+        .spawn_bundle(LightBundle {
+            transform: Transform::from_xyz(3.0, 5.0, 3.0),
+            ..Default::default()
+        })
+        .insert(Rotates);
+}
+
+/// this component indicates what entities should rotate
+struct Rotates;
+
+fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
+    for mut transform in query.iter_mut() {
+        *transform = Transform::from_rotation(Quat::from_rotation_y(
+            (4.0 * std::f32::consts::PI / 20.0) * time.delta_seconds(),
+        )) * *transform;
+    }
+}
+
+fn key_bow_system(time: Res<Time>, mut query: Query<&mut Transform, With<Key>>) {
+    let mut i = 0;
+
+    for mut transform in query.iter_mut() {
+        *transform = Transform::from_translation(Vec3::new(
+            0.,
+            (time.seconds_since_startup() as f32 * 3. + i as f32 / 8.).sin() * -0.02,
+            0.,
+        )) * *transform;
+        i += 1;
+    }
+}
+
+fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mut Transform)>, settings: Res<MidiSettings>) {
+    let mut key_str = "".to_string();
+    let mut midi_type: u8 = 0;
+    for midi_event in events.iter() {
+        let a = translate(&midi_event.message, *settings);
+        midi_type = a.0;
+        key_str = a.1;
+    }
+
+    //NoteOn
+    if midi_type.eq(&settings.note_on) {
+        for (key, mut transform) in query.iter_mut() {
+            if key.0 == key_str {
+                if transform.translation.y > -0.1 {
+                    transform.translation = Vec3::new(
+                        transform.translation.x,
+                        transform.translation.y - 0.1,
+                        transform.translation.z,
+                    );
+                }
+            }
+        }
+    //NoteOff
+    } else if midi_type.eq(&settings.note_off) {
+        for (key, mut transform) in query.iter_mut() {
+            if key.0 == key_str {
+                transform.translation =
+                    Vec3::new(transform.translation.x, key.1, transform.translation.z);
+            }
+        }
+    }
+}
diff --git a/examples/piano.rs b/examples/piano.rs
index bfcc9fc..1fabdf3 100644
--- a/examples/piano.rs
+++ b/examples/piano.rs
@@ -1,6 +1,6 @@
 use bevy::{pbr::AmbientLight, prelude::*};
 use bevy_config_cam::ConfigCam;
-use bevy_midi::{translate, Midi, MidiEvent};
+use bevy_midi::{Midi, MidiEvent, MidiSettings, translate};
 
 #[derive(Debug)]
 struct Key(String, f32);
@@ -236,17 +236,17 @@ fn key_bow_system(time: Res<Time>, mut query: Query<&mut Transform, With<Key>>)
     }
 }
 
-fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mut Transform)>) {
+fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mut Transform)>, settings: Res<MidiSettings>) {
     let mut key_str = "".to_string();
     let mut midi_type: u8 = 0;
     for midi_event in events.iter() {
-        let a = translate(&midi_event.message);
+        let a = translate(&midi_event.message, &settings);
         midi_type = a.0;
         key_str = a.1;
     }
 
     //NoteOn
-    if midi_type.eq(&144) {
+    if midi_type.eq(&settings.note_on) {
         for (key, mut transform) in query.iter_mut() {
             if key.0 == key_str {
                 if transform.translation.y > -0.1 {
@@ -259,7 +259,7 @@ fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mu
             }
         }
     //NoteOff
-    } else if midi_type.eq(&128) {
+    } else if midi_type.eq(&settings.note_off) {
         for (key, mut transform) in query.iter_mut() {
             if key.0 == key_str {
                 transform.translation =
diff --git a/examples/simple.rs b/examples/simple.rs
index 618262d..e7edfc1 100644
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -5,13 +5,16 @@ fn main() {
     App::build()
         .add_plugins(MinimalPlugins)
         .add_plugin(Midi)
-        .insert_resource(MidiSettings { is_debug: false })
+        .insert_resource(MidiSettings { 
+            is_debug: false, 
+            ..Default::default() 
+        })
         .add_system(midi_listener.system())
         .run();
 }
 
-fn midi_listener(mut events: EventReader<MidiEvent>) {
+fn midi_listener(mut events: EventReader<MidiEvent>, settings: Res<MidiSettings>) {
     for midi_event in events.iter() {
-        translate(&midi_event.message);
+        translate(&midi_event.message, *settings);
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index c456e42..ca39006 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,13 +28,20 @@ impl Plugin for Midi {
     }
 }
 
+#[derive(Clone, Copy)]
 pub struct MidiSettings {
     pub is_debug: bool,
+    pub note_on: u8,
+    pub note_off: u8,
 }
 
 impl Default for MidiSettings {
     fn default() -> Self {
-        Self { is_debug: true }
+        Self { 
+            is_debug: true,
+            note_on: 144,
+            note_off: 128, 
+        }
     }
 }
 
@@ -166,9 +173,9 @@ fn run_if_debug(settings: Res<MidiSettings>) -> ShouldRun {
     }
 }
 
-fn midi_listener(mut events: EventReader<MidiEvent>) {
+fn midi_listener(mut events: EventReader<MidiEvent>, settings: Res<MidiSettings>) {
     for midi_event in events.iter() {
-        translate(&midi_event.message);
+        translate(&midi_event.message, *settings);
     }
 }
 
@@ -176,14 +183,14 @@ const KEY_RANGE: [&str; 12] = [
     "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
 ];
 
-pub fn translate(message: &[u8]) -> (u8, String) {
+pub fn translate(message: &[u8], settings: MidiSettings) -> (u8, String) {
     let msg = message[1];
     let off = msg % 12;
     let oct = msg.overflowing_div(12).0;
 
-    let midi_type = if message[0].eq(&144) {
+    let midi_type = if message[0].eq(&settings.note_on) {
         "NoteOn"
-    } else if message[0].eq(&128) {
+    } else if message[0].eq(&settings.note_off) {
         "NoteOff"
     } else {
         "Other"

From d9e034aabf4bf3f53b1ef027725947bbf605e0dd Mon Sep 17 00:00:00 2001
From: BlackPhlox <mlr@redbarnet.dk>
Date: Mon, 22 Nov 2021 02:23:30 +0100
Subject: [PATCH 2/3] 0.2 Update

---
 .gitignore                        |   2 +
 Cargo.lock                        |   9 +-
 Cargo.toml                        |  11 +-
 LICENSE-APACHE                    |  13 ++
 LICENSE-MIT                       |  23 +++
 README.md                         |  41 ++--
 credits/CREDITS.md                |  13 --
 credits/licenses/bevy_MIT.md      |  21 --
 credits/licenses/bevy_midi_ISC.md |   7 -
 credits/licenses/bevy_midi_MIT.md |  21 --
 credits/licenses/midir_MIT.md     |  21 --
 examples/adsick_piano.rs          | 275 ------------------------
 examples/browser/Cargo.lock       | 333 ++++++++++++++++++++++++++++++
 examples/browser/Cargo.toml       |  15 ++
 examples/browser/index.html       |  18 ++
 examples/browser/src/lib.rs       |  96 +++++++++
 examples/minimal.rs               |   3 +-
 examples/piano.rs                 | 321 ++++++++--------------------
 examples/simple.rs                |  20 --
 src/lib.rs                        | 265 ++++++++----------------
 20 files changed, 702 insertions(+), 826 deletions(-)
 create mode 100644 LICENSE-APACHE
 create mode 100644 LICENSE-MIT
 delete mode 100644 credits/CREDITS.md
 delete mode 100644 credits/licenses/bevy_MIT.md
 delete mode 100644 credits/licenses/bevy_midi_ISC.md
 delete mode 100644 credits/licenses/bevy_midi_MIT.md
 delete mode 100644 credits/licenses/midir_MIT.md
 delete mode 100644 examples/adsick_piano.rs
 create mode 100644 examples/browser/Cargo.lock
 create mode 100644 examples/browser/Cargo.toml
 create mode 100644 examples/browser/index.html
 create mode 100644 examples/browser/src/lib.rs
 delete mode 100644 examples/simple.rs

diff --git a/.gitignore b/.gitignore
index 8d935a6..4635714 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,5 @@
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+
+package-lock.json
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 1e0d425..b56eb84 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,5 +1,7 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+version = 3
+
 [[package]]
 name = "Inflector"
 version = "0.11.4"
@@ -251,9 +253,9 @@ dependencies = [
 
 [[package]]
 name = "bevy_config_cam"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2e51d03c281477dd4bce002b96d25fbbc9eb2c4599e841f7670b64729dabbed"
+checksum = "8fc56ac3762511878ec7314c0247a4eb494fbf6ef27ae38c5c9a7e75a5804fc3"
 dependencies = [
  "bevy",
  "rand",
@@ -428,10 +430,11 @@ dependencies = [
 
 [[package]]
 name = "bevy_midi"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "bevy",
  "bevy_config_cam",
+ "crossbeam-channel",
  "midir",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 79a521b..1c5a1b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "bevy_midi"
-version = "0.1.0"
-authors = ["BlackPhlox <theluja@gmail.com>"]
-edition = "2018"
-license = "MIT OR ISC"
+version = "0.2.0"
+authors = ["Black Phlox <bphlox@gmail.com>"]
+edition = "2021"
+license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/BlackPhlox/bevy_midi"
 documentation = "https://docs.rs/bevy_midi"
@@ -22,13 +22,14 @@ name = "bevy_midi"
 
 [dependencies]
 midir = "0.7.0"
+crossbeam-channel = "0.5.1"
 
 [dependencies.bevy]
 version = "0.5"
 default-features = false
 
 [dev-dependencies]
-bevy_config_cam = "0.1.2"
+bevy_config_cam = "0.1.3"
 
 [dev-dependencies.bevy]
 version = "0.5"
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
new file mode 100644
index 0000000..cf82a5a
--- /dev/null
+++ b/LICENSE-APACHE
@@ -0,0 +1,13 @@
+Copyright 2021 Mikkel Rasmussen
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
index 70a3752..15f715a 100644
--- a/README.md
+++ b/README.md
@@ -1,20 +1,27 @@
-
-
-
-# bevy_midi
-
-A bevy plugin using [midir](https://github.com/Boddlnagg/midir). This plugin allows you to read or write midi data for a selected midi input.</br>(Currently, write is not implemented yet)
-
-[![crates.io](https://img.shields.io/crates/v/bevy_midi)](https://crates.io/crates/bevy_midi)</br>[![docs.rs](https://docs.rs/bevy_midi/badge.svg)](https://docs.rs/bevy_midi)
-
+<div align="left">
+<a href="https://github.com/BlackPhlox/bevy_midi"><img src="https://raw.githubusercontent.com/BlackPhlox/BlackPhlox/master/bevy_midi.svg" alt="bevy_midi"></a>
+</div>
+
+
+<div align="left">
+<a href="https://crates.io/crates/bevy_midi"><img src="https://img.shields.io/crates/v/bevy_midi" alt="link to crates.io"></a>
+<a href="https://docs.rs/bevy_midi"><img src="https://docs.rs/bevy_midi/badge.svg" alt="link to docs.rs"></a>
+<a href="https://github.com/BlackPhlox/bevy_midi/blob/master/LICENSE-MIT"><img src="https://img.shields.io/crates/l/bevy_midi" alt="link to license"></a>
+<a href="https://crates.io/crates/bevy_midi"><img src="https://img.shields.io/crates/d/bevy_midi" alt="downloads/link to crates.io"></a>   
+<a href="https://github.com/BlackPhlox/bevy_midi"><img src="https://img.shields.io/github/stars/BlackPhlox/bevy_midi" alt="stars/github repo"></a>
+<a href="https://github.com/BlackPhlox/bevy_midi/actions/workflows/master.yml"><img src="https://github.com/BlackPhlox/bevy_midi/actions/workflows/master.yml/badge.svg" alt="github actions"></a>
+<a href="https://github.com/bevyengine/bevy/blob/main/docs/plugins_guidelines.md#main-branch-tracking"><img src="https://img.shields.io/badge/Bevy%20tracking-released%20version-lightblue" alt="tracking bevy release branch"></a>
+</div>
+</br>
+
+A bevy plugin using [midir](https://github.com/Boddlnagg/midir) and [crossbeam-channel](https://github.com/crossbeam-rs/crossbeam). This plugin allows you to read or write midi data for a selected midi input.</br>(Currently, write is not implemented yet)
 ## Showcase
 
 Run the examples using:</br>
 
-`cargo run --release --example minimal`
-,</br>
-`cargo run --release --example simple` or</br>
-`cargo run --release --example piano`
+Terminal only: 
+`cargo run --release --example minimal`</br>
+Virtual Piano: `cargo run --release --example piano`
 
 Running the piano example:</br>
 
@@ -22,19 +29,21 @@ https://user-images.githubusercontent.com/25123512/122971334-3bae6100-d38f-11eb-
 
 Notice: Sustain is not handled by the example
 
+Browser support: Still work in progress.
 # Setup
 
-Todo
+See examples
 
 # Support
 [![Bevy tracking](https://img.shields.io/badge/Bevy%20tracking-released%20version-lightblue)](https://github.com/bevyengine/bevy/blob/main/docs/plugins_guidelines.md#main-branch-tracking)
 
-|bevy|bevy_osc|
+|bevy|bevy_midi|
 |---|---|
 |0.5|0.1.X|
+|0.5|0.2.X|
 
 # Licensing
-The project is under dual license MIT and ISC (functionally equivalent, though ISC removing some language that is no longer necessary), so yoink to your hearts content, just remember the license agreements.
+The project is under dual license MIT and Apache 2.0, so joink to your hearts content, just remember the license agreements.
 
 # Contributing
 Yes this project is still very much WIP, so PRs are very welcome
diff --git a/credits/CREDITS.md b/credits/CREDITS.md
deleted file mode 100644
index 52223d0..0000000
--- a/credits/CREDITS.md
+++ /dev/null
@@ -1,13 +0,0 @@
-# Credits
-
-## Current
-
-* [bevy_midi*](https://github.com/BlackPhlox/bevy_midi): [ISC License](licenses/bevy_midi_ISC.md); Copyright (c) 2021 Mikkel Rasmussen
-* [bevy_midi*](https://github.com/BlackPhlox/bevy_midi): [MIT License](licenses/bevy_midi_MIT.md); Copyright (c) 2021 Mikkel Rasmussen
-
-\* Also pertained to all assets included in the project
-
-## Libraries
-
-* [bevy](https://github.com/bevyengine/bevy): [MIT License](licenses/bevy_MIT.md); Copyright (c) 2020 Carter Anderson
-* [midir](https://github.com/Boddlnagg/midir): [MIT License](licenses/midir_MIT.md); Copyright (c) 2015 Patrick Reisert and the RtMidi contributors
diff --git a/credits/licenses/bevy_MIT.md b/credits/licenses/bevy_MIT.md
deleted file mode 100644
index 9d1f4a3..0000000
--- a/credits/licenses/bevy_MIT.md
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Carter Anderson
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
\ No newline at end of file
diff --git a/credits/licenses/bevy_midi_ISC.md b/credits/licenses/bevy_midi_ISC.md
deleted file mode 100644
index 46ede0e..0000000
--- a/credits/licenses/bevy_midi_ISC.md
+++ /dev/null
@@ -1,7 +0,0 @@
-ISC License
-
-Copyright 2021 Mikkel Rasmussen
-
-Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/credits/licenses/bevy_midi_MIT.md b/credits/licenses/bevy_midi_MIT.md
deleted file mode 100644
index 75e3d06..0000000
--- a/credits/licenses/bevy_midi_MIT.md
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Mikkel Rasmussen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
\ No newline at end of file
diff --git a/credits/licenses/midir_MIT.md b/credits/licenses/midir_MIT.md
deleted file mode 100644
index cc47bb4..0000000
--- a/credits/licenses/midir_MIT.md
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Patrick Reisert and the RtMidi contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
\ No newline at end of file
diff --git a/examples/adsick_piano.rs b/examples/adsick_piano.rs
deleted file mode 100644
index 0998053..0000000
--- a/examples/adsick_piano.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use bevy::{pbr::AmbientLight, prelude::*};
-use bevy_config_cam::ConfigCam;
-use bevy_midi::{Midi, MidiEvent, MidiSettings, translate};
-
-#[derive(Debug)]
-struct Key(String, f32);
-
-fn main() {
-    App::build()
-        .insert_resource(AmbientLight {
-            color: Color::WHITE,
-            brightness: 1.0 / 5.0f32,
-        })
-        .insert_resource(Msaa { samples: 4 })
-        .add_plugin(ConfigCam)
-        .add_plugin(Midi)
-        .insert_resource(MidiSettings { 
-            note_on: 156,
-            note_off: 140,
-            ..Default::default() 
-        })
-        .add_plugins(DefaultPlugins)
-        .add_startup_system(setup.system())
-        .add_startup_system(setup_piano.system())
-        .add_system(rotator_system.system())
-        .add_system(midi_listener.system())
-        //.add_system(key_bow_system.system())
-        .run();
-}
-
-fn setup_piano(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let pos: Vec3 = Vec3::new(0., 0., 0.);
-
-    let black_key: Handle<Scene> = asset_server.load("models/black_key.gltf#Scene0");
-    let white_key_0: Handle<Scene> = asset_server.load("models/white_key_0.gltf#Scene0");
-    let white_key_1: Handle<Scene> = asset_server.load("models/white_key_1.gltf#Scene0");
-    let white_key_2: Handle<Scene> = asset_server.load("models/white_key_2.gltf#Scene0");
-
-    //Building the keyboard of every octave section
-    for i in 0..8 {
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("C{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_0.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.15 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("C#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.27 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("D{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.39 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("D#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.54 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("E{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_2.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.69 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("F{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_0.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.85 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("F#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.96 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("G{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.08 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("G#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.19 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("A{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.31 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("A#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.46 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("B{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_2.clone());
-            });
-    }
-}
-
-fn setup(mut commands: Commands) {
-    commands
-        .spawn_bundle(LightBundle {
-            transform: Transform::from_xyz(3.0, 5.0, 3.0),
-            ..Default::default()
-        })
-        .insert(Rotates);
-}
-
-/// this component indicates what entities should rotate
-struct Rotates;
-
-fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
-    for mut transform in query.iter_mut() {
-        *transform = Transform::from_rotation(Quat::from_rotation_y(
-            (4.0 * std::f32::consts::PI / 20.0) * time.delta_seconds(),
-        )) * *transform;
-    }
-}
-
-fn key_bow_system(time: Res<Time>, mut query: Query<&mut Transform, With<Key>>) {
-    let mut i = 0;
-
-    for mut transform in query.iter_mut() {
-        *transform = Transform::from_translation(Vec3::new(
-            0.,
-            (time.seconds_since_startup() as f32 * 3. + i as f32 / 8.).sin() * -0.02,
-            0.,
-        )) * *transform;
-        i += 1;
-    }
-}
-
-fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mut Transform)>, settings: Res<MidiSettings>) {
-    let mut key_str = "".to_string();
-    let mut midi_type: u8 = 0;
-    for midi_event in events.iter() {
-        let a = translate(&midi_event.message, *settings);
-        midi_type = a.0;
-        key_str = a.1;
-    }
-
-    //NoteOn
-    if midi_type.eq(&settings.note_on) {
-        for (key, mut transform) in query.iter_mut() {
-            if key.0 == key_str {
-                if transform.translation.y > -0.1 {
-                    transform.translation = Vec3::new(
-                        transform.translation.x,
-                        transform.translation.y - 0.1,
-                        transform.translation.z,
-                    );
-                }
-            }
-        }
-    //NoteOff
-    } else if midi_type.eq(&settings.note_off) {
-        for (key, mut transform) in query.iter_mut() {
-            if key.0 == key_str {
-                transform.translation =
-                    Vec3::new(transform.translation.x, key.1, transform.translation.z);
-            }
-        }
-    }
-}
diff --git a/examples/browser/Cargo.lock b/examples/browser/Cargo.lock
new file mode 100644
index 0000000..1308e5c
--- /dev/null
+++ b/examples/browser/Cargo.lock
@@ -0,0 +1,333 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "alsa"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb213f6b3e4b1480a60931ca2035794aa67b73103d254715b1db7b70dcb3c934"
+dependencies = [
+ "alsa-sys",
+ "bitflags",
+ "libc",
+ "nix",
+]
+
+[[package]]
+name = "alsa-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "bevy_midi_browser"
+version = "0.1.0"
+dependencies = [
+ "console_error_panic_hook",
+ "js-sys",
+ "midir",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bumpalo"
+version = "3.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
+
+[[package]]
+name = "cc"
+version = "1.0.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25bfd746d203017f7d5cbd31ee5d8e17f94b6521c7af77ece6c9e4b2d4b16c67"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "065a5d7ffdcbc8fa145d6f0746f3555025b9097a9e9cda59f7467abae670c78d"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "coremidi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99f92de5534f182bad5f91cad85611ab222cb6e237a0555e06c65a24936c3173"
+dependencies = [
+ "core-foundation",
+ "core-foundation-sys",
+ "coremidi-sys",
+ "time",
+]
+
+[[package]]
+name = "coremidi-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07f05827cebb30dcd539ff1ac9bf6764f574a15fa147f8572f99d7617142f95e"
+dependencies = [
+ "core-foundation-sys",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cc9ffccd38c451a86bf13657df244e9c3f37493cce8e5e21e940963777acc84"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8521a1b57e76b1ec69af7599e75e38e7b7fad6610f037db8c79b127201b5d119"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "memalloc"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df39d232f5c40b0891c10216992c2f250c054105cb1e56f0fc9032db6203ecc1"
+
+[[package]]
+name = "midir"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25df1e7836ca65078a121efed77049084a434838562b9892d0401bdfb59244cc"
+dependencies = [
+ "alsa",
+ "bitflags",
+ "coremidi",
+ "js-sys",
+ "libc",
+ "memalloc",
+ "nix",
+ "wasm-bindgen",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "nix"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2e0b4f3320ed72aaedb9a5ac838690a8047c7b275da22711fddff4f8a14229"
+dependencies = [
+ "bitflags",
+ "cc",
+ "cfg-if 0.1.10",
+ "libc",
+ "void",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "time"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
+dependencies = [
+ "libc",
+ "wasi",
+ "winapi",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
+dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc"
+
+[[package]]
+name = "web-sys"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38eb105f1c59d9eaa6b5cdc92b859d85b926e82cb2e0945cd0c9259faa6fe9fb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/examples/browser/Cargo.toml b/examples/browser/Cargo.toml
new file mode 100644
index 0000000..bb0631f
--- /dev/null
+++ b/examples/browser/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "bevy_midi_browser"
+version = "0.1.0"
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+midir = "0.7.0"
+
+console_error_panic_hook = "0.1.6"
+web-sys = { version = "0.3", features = ["console", "Window"]}
+js-sys = "0.3"
+wasm-bindgen = "0.2"
\ No newline at end of file
diff --git a/examples/browser/index.html b/examples/browser/index.html
new file mode 100644
index 0000000..95d1942
--- /dev/null
+++ b/examples/browser/index.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html><head>
+    <meta charset="utf-8"/>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>midir &ndash; examples/browser</title>
+</head><body>
+    <script src="pkg/bevy_midi_browser.js"></script>
+    <script>
+        // fetch doesn't work over file:// in Chrome, despite using --allow-file-access-from-files, so use XHR instead.
+        var xhr = new XMLHttpRequest();
+        xhr.responseType = "arraybuffer";
+        xhr.addEventListener("load", function(load) {
+            wasm_bindgen(xhr.response).then(function(wasm) {});
+        });
+        xhr.open("GET", "pkg/bevy_midi_browser_bg.wasm");
+        xhr.send();
+    </script>
+</body></html>
\ No newline at end of file
diff --git a/examples/browser/src/lib.rs b/examples/browser/src/lib.rs
new file mode 100644
index 0000000..cbf4b5e
--- /dev/null
+++ b/examples/browser/src/lib.rs
@@ -0,0 +1,96 @@
+//Remember to install wasm-pack
+//cargo install wasm-pack
+//if windows: 
+//https://rustwasm.github.io/wasm-pack/installer/#
+
+extern crate midir;
+extern crate console_error_panic_hook;
+extern crate js_sys;
+extern crate web_sys;
+extern crate wasm_bindgen;
+
+use js_sys::{Array};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use web_sys::{console};
+
+use std::sync::{Arc, Mutex};
+use std::error::Error;
+
+use midir::{MidiInput, Ignore};
+
+pub fn log(s: String) {
+    console::log(&Array::of1(&s.into()));
+}
+
+macro_rules! println {
+    ()              => (log("".to_owned()));
+    ($($arg:tt)*)   => (log(format!($($arg)*)));
+}
+
+#[wasm_bindgen(start)]
+pub fn start() {
+    std::panic::set_hook(Box::new(console_error_panic_hook::hook));
+
+    let token_outer = Arc::new(Mutex::new(None));
+    let token = token_outer.clone();
+    let closure : Closure<dyn FnMut()> = Closure::wrap(Box::new(move ||{
+        if run().unwrap() == true {
+            if let Some(token) = *token.lock().unwrap() {
+                web_sys::window().unwrap().clear_interval_with_handle(token);
+            }
+        }
+    }));
+    *token_outer.lock().unwrap() = web_sys::window().unwrap().set_interval_with_callback_and_timeout_and_arguments_0(
+        closure.as_ref().unchecked_ref(),
+        200,
+    ).ok();
+    closure.forget();
+}
+
+fn run() -> Result<bool, Box<dyn Error>> {
+    let window = web_sys::window().expect("no global `window` exists");
+
+    let mut midi_in = MidiInput::new("midir reading input")?;
+    midi_in.ignore(Ignore::None);
+
+    // Get an input port
+    let ports = midi_in.ports();
+    let in_port = match &ports[..] {
+        [] => {
+            println!("No ports available yet, will try again");
+            return Ok(false)
+        },
+        [ref port] => {
+            println!("Choosing the only available input port: {}", midi_in.port_name(port).unwrap());
+            port
+        },
+        _ => {
+            let mut msg = "Choose an available input port:\n".to_string();
+            for (i, port) in ports.iter().enumerate() {
+                msg.push_str(format!("{}: {}\n", i, midi_in.port_name(port).unwrap()).as_str());
+            }
+            loop {
+                if let Ok(Some(port_str)) = window.prompt_with_message_and_default(&msg, "0") {
+                    if let Ok(port_int) = port_str.parse::<usize>() {
+                        if let Some(port) = &ports.get(port_int) {
+                            break port.clone()
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    println!("Opening connection");
+    let in_port_name = midi_in.port_name(in_port)?;
+
+    // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
+    let _conn_in = midi_in.connect(in_port, "midir-read-input", move |stamp, message, _| {
+        println!("{}: {:?} (len = {})", stamp, message, message.len());
+    }, ())?;
+
+    println!("Connection open, reading input from '{}'", in_port_name);
+    Box::leak(Box::new(_conn_in));
+    Ok(true)
+}
\ No newline at end of file
diff --git a/examples/minimal.rs b/examples/minimal.rs
index 725906e..5c9a0e0 100644
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -1,7 +1,8 @@
+#![warn(clippy::pedantic)]
+
 use bevy::prelude::*;
 use bevy_midi::Midi;
 
-// Uses default behavior, logs the 5 latest osc messages
 fn main() {
     App::build()
         .add_plugins(MinimalPlugins)
diff --git a/examples/piano.rs b/examples/piano.rs
index 1fabdf3..06478cd 100644
--- a/examples/piano.rs
+++ b/examples/piano.rs
@@ -1,9 +1,7 @@
 use bevy::{pbr::AmbientLight, prelude::*};
 use bevy_config_cam::ConfigCam;
-use bevy_midi::{Midi, MidiEvent, MidiSettings, translate};
-
-#[derive(Debug)]
-struct Key(String, f32);
+use bevy_midi::{KEY_RANGE, Midi, MidiRawData, MidiSettings};
+use crossbeam_channel::Receiver;
 
 fn main() {
     App::build()
@@ -11,260 +9,105 @@ fn main() {
             color: Color::WHITE,
             brightness: 1.0 / 5.0f32,
         })
-        .insert_resource(Msaa { samples: 4 })
+        .add_plugins(DefaultPlugins)
         .add_plugin(ConfigCam)
         .add_plugin(Midi)
-        .add_plugins(DefaultPlugins)
+        .insert_resource(MidiSettings {
+            is_debug: false,
+            ..Default::default()
+        })
         .add_startup_system(setup.system())
-        .add_startup_system(setup_piano.system())
-        .add_system(rotator_system.system())
-        .add_system(midi_listener.system())
-        //.add_system(key_bow_system.system())
+        .add_system(handle_midi_input.system())
         .run();
 }
 
-fn setup_piano(mut commands: Commands, asset_server: Res<AssetServer>) {
+#[derive(Debug)]
+struct Key{
+    key_val: String,
+    y_reset: f32,
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     let pos: Vec3 = Vec3::new(0., 0., 0.);
 
-    let black_key: Handle<Scene> = asset_server.load("models/black_key.gltf#Scene0");
-    let white_key_0: Handle<Scene> = asset_server.load("models/white_key_0.gltf#Scene0");
-    let white_key_1: Handle<Scene> = asset_server.load("models/white_key_1.gltf#Scene0");
-    let white_key_2: Handle<Scene> = asset_server.load("models/white_key_2.gltf#Scene0");
+    let mut black_key: Handle<Scene> = asset_server.load("models/black_key.gltf#Scene0");
+    let mut white_key_0: Handle<Scene> = asset_server.load("models/white_key_0.gltf#Scene0");
+    let mut white_key_1: Handle<Scene> = asset_server.load("models/white_key_1.gltf#Scene0");
+    let mut white_key_2: Handle<Scene> = asset_server.load("models/white_key_2.gltf#Scene0");
 
-    //Building the keyboard of every octave section
+    //Create keyboard layout
+    let bk_off = Vec3::new(0., 0.06, 0.);
     for i in 0..8 {
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("C{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_0.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.15 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("C#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.27 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("D{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.39 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("D#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.54 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("E{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_2.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.69 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("F{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_0.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 0.85 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("F#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 0.96 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("G{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.08 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("G#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.19 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("A{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_1.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y + 0.06, pos.z - 1.31 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("A#{}", i), 0.06))
-            .with_children(|cell| {
-                cell.spawn_scene(black_key.clone());
-            });
-
-        commands
-            .spawn_bundle((
-                Transform {
-                    translation: Vec3::new(pos.x, pos.y, pos.z - 1.46 - (1.61 * i as f32)),
-                    scale: Vec3::new(10., 10., 10.),
-                    ..Default::default()
-                },
-                GlobalTransform::identity(),
-            ))
-            .insert(Key(format!("B{}", i), 0.))
-            .with_children(|cell| {
-                cell.spawn_scene(white_key_2.clone());
-            });
+        spawn_note(&mut commands, 0.00, pos, &mut white_key_0, i, "C");
+        spawn_note(&mut commands, 0.15, pos + bk_off, &mut black_key, i, "C#");
+        spawn_note(&mut commands, 0.27, pos, &mut white_key_1, i, "D");
+        spawn_note(&mut commands, 0.39, pos + bk_off, &mut black_key, i, "D#");
+        spawn_note(&mut commands, 0.54, pos, &mut white_key_2, i, "E");
+        spawn_note(&mut commands, 0.69, pos, &mut white_key_0, i, "F");
+        spawn_note(&mut commands, 0.85, pos + bk_off, &mut black_key, i, "F#");
+        spawn_note(&mut commands, 0.96, pos, &mut white_key_1, i, "G");
+        spawn_note(&mut commands, 1.08, pos + bk_off, &mut black_key, i, "G#");
+        spawn_note(&mut commands, 1.19, pos, &mut white_key_1, i, "A");
+        spawn_note(&mut commands, 1.31, pos + bk_off, &mut black_key, i, "A#");
+        spawn_note(&mut commands, 1.46, pos, &mut white_key_2, i, "B");
     }
 }
 
-fn setup(mut commands: Commands) {
+fn spawn_note(
+    commands: &mut Commands,
+    offset_z: f32,
+    pos: Vec3,
+    asset: &mut Handle<Scene>,
+    oct: i32,
+    key: &str,
+) {
     commands
-        .spawn_bundle(LightBundle {
-            transform: Transform::from_xyz(3.0, 5.0, 3.0),
-            ..Default::default()
-        })
-        .insert(Rotates);
+        .spawn_bundle((
+            Transform {
+                translation: Vec3::new(pos.x, pos.y, pos.z - offset_z - (1.61 * oct as f32)),
+                scale: Vec3::new(10., 10., 10.),
+                ..Default::default()
+            },
+            GlobalTransform::identity(),
+        ))
+        .insert(Key{ key_val: format!("{}{}", key, oct), y_reset: pos.y})
+        .with_children(|cell| {
+            cell.spawn_scene(asset.clone());
+        });
 }
 
-/// this component indicates what entities should rotate
-struct Rotates;
-
-fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
-    for mut transform in query.iter_mut() {
-        *transform = Transform::from_rotation(Quat::from_rotation_y(
-            (4.0 * std::f32::consts::PI / 20.0) * time.delta_seconds(),
-        )) * *transform;
-    }
-}
-
-fn key_bow_system(time: Res<Time>, mut query: Query<&mut Transform, With<Key>>) {
-    let mut i = 0;
-
-    for mut transform in query.iter_mut() {
-        *transform = Transform::from_translation(Vec3::new(
-            0.,
-            (time.seconds_since_startup() as f32 * 3. + i as f32 / 8.).sin() * -0.02,
-            0.,
-        )) * *transform;
-        i += 1;
-    }
-}
-
-fn midi_listener(mut events: EventReader<MidiEvent>, mut query: Query<(&Key, &mut Transform)>, settings: Res<MidiSettings>) {
-    let mut key_str = "".to_string();
-    let mut midi_type: u8 = 0;
-    for midi_event in events.iter() {
-        let a = translate(&midi_event.message, &settings);
-        midi_type = a.0;
-        key_str = a.1;
-    }
-
-    //NoteOn
-    if midi_type.eq(&settings.note_on) {
-        for (key, mut transform) in query.iter_mut() {
-            if key.0 == key_str {
-                if transform.translation.y > -0.1 {
-                    transform.translation = Vec3::new(
-                        transform.translation.x,
-                        transform.translation.y - 0.1,
-                        transform.translation.z,
-                    );
+fn handle_midi_input(
+    receiver: Res<Receiver<MidiRawData>>,
+    mut query: Query<(&Key, &mut Transform)>,
+    settings: Res<MidiSettings>,
+) {
+    if let Ok(data) = receiver.try_recv() {
+        let [event, index, value] = data.message;
+        let off = index % 12;
+        let oct = index.overflowing_div(12).0;
+        let key_str = KEY_RANGE.iter().nth(off.into()).unwrap();
+
+        if event.eq(&settings.note_on) {
+            for (key, mut transform) in query.iter_mut() {
+                if key.key_val.eq(&format!("{}{}",key_str,oct).to_string()) {
+                    if transform.translation.y > -0.1 {
+                        transform.translation = Vec3::new(
+                            transform.translation.x,
+                            transform.translation.y - 0.1,
+                            transform.translation.z,
+                        );
+                    }
                 }
             }
-        }
-    //NoteOff
-    } else if midi_type.eq(&settings.note_off) {
-        for (key, mut transform) in query.iter_mut() {
-            if key.0 == key_str {
-                transform.translation =
-                    Vec3::new(transform.translation.x, key.1, transform.translation.z);
+        } else if event.eq(&settings.note_off){
+            for (key, mut transform) in query.iter_mut() {
+                if key.key_val.eq(&format!("{}{}",key_str,oct).to_string()) {
+                    transform.translation =
+                        Vec3::new(transform.translation.x, key.y_reset, transform.translation.z);
+                }
             }
+        } else {
+
         }
     }
 }
diff --git a/examples/simple.rs b/examples/simple.rs
deleted file mode 100644
index e7edfc1..0000000
--- a/examples/simple.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use bevy::prelude::*;
-use bevy_midi::{translate, Midi, MidiEvent, MidiSettings};
-
-fn main() {
-    App::build()
-        .add_plugins(MinimalPlugins)
-        .add_plugin(Midi)
-        .insert_resource(MidiSettings { 
-            is_debug: false, 
-            ..Default::default() 
-        })
-        .add_system(midi_listener.system())
-        .run();
-}
-
-fn midi_listener(mut events: EventReader<MidiEvent>, settings: Res<MidiSettings>) {
-    for midi_event in events.iter() {
-        translate(&midi_event.message, *settings);
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index ca39006..cc5f66b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,33 +1,29 @@
-use std::{
-    io::{stdin, stdout, Write},
-    sync::{Arc, Mutex, MutexGuard},
-    thread,
-};
-
-use bevy::{
-    ecs::schedule::ShouldRun,
-    prelude::{AppBuilder, EventReader, EventWriter, IntoSystem, Plugin, Res, ResMut, SystemSet},
-};
+use bevy::ecs::schedule::ShouldRun;
+use bevy::prelude::{AppBuilder, Plugin};
+use bevy::{prelude::*, tasks::IoTaskPool};
+use crossbeam_channel::{unbounded, Receiver, Sender};
 use midir::{Ignore, MidiInput};
+use std::io::{stdin, stdout, Write};
 
 pub struct Midi;
 impl Plugin for Midi {
     fn build(&self, app: &mut AppBuilder) {
         app.init_resource::<MidiSettings>()
-            .init_resource::<MidiLog>()
-            .add_event::<MidiEvent>()
-            .insert_resource(MidiStamp { stamp: 0_u64 })
-            .add_startup_system(midi_setup.system())
-            .add_system(midi_sender.system())
+            .add_startup_system(setup.system())
             .add_system_set(
                 SystemSet::new()
                     .with_run_criteria(run_if_debug.system())
-                    .before("input")
-                    .with_system(midi_listener.system()),
+                    .with_system(debug_midi.system()),
             );
     }
 }
 
+fn setup(mut commands: Commands, task_pool: Res<IoTaskPool>) {
+    let (sender, receiver) = unbounded::<MidiRawData>();
+    task_pool.spawn(handshake(sender)).detach();
+    commands.insert_resource(receiver);
+}
+
 #[derive(Clone, Copy)]
 pub struct MidiSettings {
     pub is_debug: bool,
@@ -37,149 +33,100 @@ pub struct MidiSettings {
 
 impl Default for MidiSettings {
     fn default() -> Self {
-        Self { 
+        Self {
             is_debug: true,
             note_on: 144,
-            note_off: 128, 
+            note_off: 128,
         }
     }
 }
 
-pub struct MidiLog {
-    stamp: Arc<Mutex<[u64]>>,
-    message: Arc<Mutex<[u8]>>,
-}
-
-impl MidiLog {
-    pub fn get(&mut self) -> (MutexGuard<[u64]>, MutexGuard<[u8]>) {
-        let stmp = self.stamp.lock().unwrap();
-        let msg = self.message.lock().unwrap();
-        (stmp, msg)
+fn run_if_debug(settings: Res<MidiSettings>) -> ShouldRun {
+    if settings.is_debug {
+        ShouldRun::Yes
+    } else {
+        ShouldRun::No
     }
 }
 
-impl Default for MidiLog {
-    fn default() -> Self {
-        Self {
-            stamp: Arc::new(Mutex::new([0_u64])),
-            message: Arc::new(Mutex::new([0, 0, 0])),
-        }
-    }
+pub struct MidiRawData {
+    pub stamp: u64,
+    pub message: [u8; 3],
 }
 
-fn midi_setup(log: Res<MidiLog>) {
-    let thread_stamp = log.stamp.clone();
-    let thread_msg = log.message.clone();
-
-    let _t = thread::Builder::new().name("Midi Input".into()).spawn(|| {
-        {
-            let mut input = String::new();
-
-            let mut midi_in: MidiInput = MidiInput::new("midir reading input").unwrap();
-            midi_in.ignore(Ignore::None);
-
-            // Get an input port (read from console if multiple are available)
-            let in_ports = midi_in.ports();
-            let in_port = match in_ports.len() {
-                //0 => return Err("no input port found".into()),
-                1 => {
-                    println!(
-                        "Choosing the only available input port: {}",
-                        midi_in.port_name(&in_ports[0]).unwrap()
-                    );
-                    &in_ports[0]
-                }
-                _ => {
-                    println!("\nAvailable input ports:");
-                    for (i, p) in in_ports.iter().enumerate() {
-                        println!("{}: {}", i, midi_in.port_name(p).unwrap());
-                    }
-                    print!("Please select input port: ");
-                    stdout().flush().unwrap();
-                    let mut input = String::new();
-                    stdin().read_line(&mut input).unwrap();
-                    in_ports
-                        .get(input.trim().parse::<usize>().unwrap())
-                        .ok_or("invalid input port selected")
-                        .unwrap()
-                }
-            };
-
-            println!("\nOpening connection");
-            let in_port_name = midi_in.port_name(in_port).unwrap();
-
-            // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
-            let _conn_in = midi_in
-                .connect(
-                    in_port,
-                    "midir-read-input",
-                    move |stamp, message, _| {
-                        let mut data = thread_msg.lock().unwrap();
-                        let mut stmp = thread_stamp.lock().unwrap();
-
-                        for (i, m) in message.iter().enumerate() {
-                            data[i] = *m;
-                        }
-
-                        stmp[0] = stamp;
-                    },
-                    (),
-                )
-                .unwrap();
+#[allow(clippy::unused_async)]
+async fn handshake(sender: Sender<MidiRawData>) {
+    let mut input = String::new();
+    let mut midi_in: MidiInput = MidiInput::new("midir reading input").unwrap();
+    midi_in.ignore(Ignore::None);
 
+    let in_ports = midi_in.ports();
+    let in_port = match in_ports.len() {
+        //0 => return Err("No input port found".into()),
+        1 => {
             println!(
-                "Connection open, reading input from '{}' (press enter to exit) ...",
-                in_port_name
+                "Choosing the only available input port: {}",
+                midi_in.port_name(&in_ports[0]).unwrap()
             );
-
-            input.clear();
-            stdin().read_line(&mut input).unwrap(); // wait for next enter key press
-
-            println!("Closing connection");
+            &in_ports[0]
         }
-    });
-}
+        _ => {
+            println!("\nAvailable input ports:");
+            for (i, p) in in_ports.iter().enumerate() {
+                println!("{}: {}", i, midi_in.port_name(p).unwrap());
+            }
+            print!("Please select input port: ");
+            stdout().flush().unwrap();
+            let mut input = String::new();
+            stdin().read_line(&mut input).unwrap();
+            in_ports
+                .get(input.trim().parse::<usize>().unwrap())
+                .ok_or("Invalid input port selected")
+                .unwrap()
+        }
+    };
 
-struct MidiStamp {
-    stamp: u64,
-}
+    println!("\nOpening connection");
+    let in_port_name = midi_in.port_name(in_port).unwrap();
 
-pub struct MidiEvent {
-    pub message: [u8; 3],
-}
+    let sender = sender.clone();
 
-fn midi_sender(
-    mut log: ResMut<MidiLog>,
-    mut rs_log: ResMut<MidiStamp>,
-    mut midi_events: EventWriter<MidiEvent>,
-) {
-    let (stamps, msg) = log.get();
-    let stamp = stamps[0];
+    // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
+    let _conn_in = midi_in
+        .connect(
+            in_port,
+            "midir-read-input",
+            move |stamp, message, _| {
+                sender
+                    .send(MidiRawData {
+                        stamp,
+                        message: [message[0], message[1], message[2]],
+                    })
+                    .unwrap();
+            },
+            (),
+        )
+        .unwrap();
 
-    if !stamp.eq(&rs_log.stamp) {
-        midi_events.send(MidiEvent {
-            message: [msg[0], msg[1], msg[2]],
-        });
+    println!(
+        "Connection open, reading input from '{}' (press enter to exit) ...",
+        in_port_name
+    );
 
-        rs_log.stamp = stamp;
-    }
-}
+    input.clear();
+    stdin().read_line(&mut input).unwrap(); // wait for next enter key press
 
-fn run_if_debug(settings: Res<MidiSettings>) -> ShouldRun {
-    if settings.is_debug {
-        ShouldRun::Yes
-    } else {
-        ShouldRun::No
-    }
+    println!("Closing connection");
 }
 
-fn midi_listener(mut events: EventReader<MidiEvent>, settings: Res<MidiSettings>) {
-    for midi_event in events.iter() {
-        translate(&midi_event.message, *settings);
+fn debug_midi(receiver: Res<Receiver<MidiRawData>>, settings: Res<MidiSettings>) {
+    if let Ok(data) = receiver.try_recv() {
+        //info!("received message: {:?}", data.message);
+        translate(&data.message, *settings);
     }
 }
 
-const KEY_RANGE: [&str; 12] = [
+pub const KEY_RANGE: [&str; 12] = [
     "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B",
 ];
 
@@ -206,53 +153,3 @@ pub fn translate(message: &[u8], settings: MidiSettings) -> (u8, String) {
     );
     (message[0], format!("{}{:?}", k, oct))
 }
-
-/*
-TODO: Re-implement error handling/aggregation
-
-fn run() -> Result<(), Box<dyn Error>> {
-    let mut input = String::new();
-
-    let mut midi_in = MidiInput::new("midir reading input")?;
-    midi_in.ignore(Ignore::None);
-
-    // Get an input port (read from console if multiple are available)
-    let in_ports = midi_in.ports();
-    let in_port = match in_ports.len() {
-        0 => return Err("no input port found".into()),
-        1 => {
-            println!("Choosing the only available input port: {}", midi_in.port_name(&in_ports[0]).unwrap());
-            &in_ports[0]
-        },
-        _ => {
-            println!("\nAvailable input ports:");
-            for (i, p) in in_ports.iter().enumerate() {
-                println!("{}: {}", i, midi_in.port_name(p).unwrap());
-            }
-            print!("Please select input port: ");
-            stdout().flush()?;
-            let mut input = String::new();
-            stdin().read_line(&mut input)?;
-            in_ports.get(input.trim().parse::<usize>()?)
-            .ok_or("invalid input port selected")?
-        }
-    };
-
-    println!("\nOpening connection");
-    let in_port_name = midi_in.port_name(in_port)?;
-
-    // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
-    let _conn_in = midi_in.connect(in_port, "midir-read-input", move |stamp, message, _| {
-        //println!("{}: {:?} (len = {})", stamp, message, message.len());
-        translate(stamp, message);
-    }, ())?;
-
-    println!("Connection open, reading input from '{}' (press enter to exit) ...", in_port_name);
-
-    input.clear();
-    stdin().read_line(&mut input)?; // wait for next enter key press
-
-    println!("Closing connection");
-    Ok(())
-}
-*/

From 059a552cb4216ec0b270ff6469fcdfc674357a9a Mon Sep 17 00:00:00 2001
From: BlackPhlox <mlr@redbarnet.dk>
Date: Mon, 22 Nov 2021 02:30:31 +0100
Subject: [PATCH 3/3] clippy & fmt

---
 examples/piano.rs | 23 ++++++++++++++---------
 src/lib.rs        |  7 ++++---
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/examples/piano.rs b/examples/piano.rs
index 06478cd..da376ed 100644
--- a/examples/piano.rs
+++ b/examples/piano.rs
@@ -1,6 +1,6 @@
 use bevy::{pbr::AmbientLight, prelude::*};
 use bevy_config_cam::ConfigCam;
-use bevy_midi::{KEY_RANGE, Midi, MidiRawData, MidiSettings};
+use bevy_midi::{Midi, MidiRawData, MidiSettings, KEY_RANGE};
 use crossbeam_channel::Receiver;
 
 fn main() {
@@ -22,7 +22,7 @@ fn main() {
 }
 
 #[derive(Debug)]
-struct Key{
+struct Key {
     key_val: String,
     y_reset: f32,
 }
@@ -70,7 +70,10 @@ fn spawn_note(
             },
             GlobalTransform::identity(),
         ))
-        .insert(Key{ key_val: format!("{}{}", key, oct), y_reset: pos.y})
+        .insert(Key {
+            key_val: format!("{}{}", key, oct),
+            y_reset: pos.y,
+        })
         .with_children(|cell| {
             cell.spawn_scene(asset.clone());
         });
@@ -89,7 +92,7 @@ fn handle_midi_input(
 
         if event.eq(&settings.note_on) {
             for (key, mut transform) in query.iter_mut() {
-                if key.key_val.eq(&format!("{}{}",key_str,oct).to_string()) {
+                if key.key_val.eq(&format!("{}{}", key_str, oct).to_string()) {
                     if transform.translation.y > -0.1 {
                         transform.translation = Vec3::new(
                             transform.translation.x,
@@ -99,15 +102,17 @@ fn handle_midi_input(
                     }
                 }
             }
-        } else if event.eq(&settings.note_off){
+        } else if event.eq(&settings.note_off) {
             for (key, mut transform) in query.iter_mut() {
-                if key.key_val.eq(&format!("{}{}",key_str,oct).to_string()) {
-                    transform.translation =
-                        Vec3::new(transform.translation.x, key.y_reset, transform.translation.z);
+                if key.key_val.eq(&format!("{}{}", key_str, oct).to_string()) {
+                    transform.translation = Vec3::new(
+                        transform.translation.x,
+                        key.y_reset,
+                        transform.translation.z,
+                    );
                 }
             }
         } else {
-
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index cc5f66b..309fc0c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -89,7 +89,7 @@ async fn handshake(sender: Sender<MidiRawData>) {
     println!("\nOpening connection");
     let in_port_name = midi_in.port_name(in_port).unwrap();
 
-    let sender = sender.clone();
+    let sender = sender;
 
     // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
     let _conn_in = midi_in
@@ -145,11 +145,12 @@ pub fn translate(message: &[u8], settings: MidiSettings) -> (u8, String) {
 
     let k = KEY_RANGE.iter().nth(off.into()).unwrap();
     println!(
-        "{}:{}{:?} - Raw: {}",
+        "{}:{}{:?} - Raw: {:?} (len = {})",
         midi_type,
         k,
         oct,
-        format!("{:?} (len = {})", message, message.len())
+        message,
+        message.len()
     );
     (message[0], format!("{}{:?}", k, oct))
 }